Création de rubans personnalisés sous Microsoft Access 2007

Comme indiqué au chapitre précédent, l'aspect du ruban est codé au sein de données XML. Ce sont ces données XML qui sont à charger dans l'application. Pour cela, l'objet Application propose la méthode LoadCustomUI. Cette méthode accepte deux arguments :

• Le nom du ruban (il sera utilisé par les formulaires Access)
• Le code XML contenant les informations relatives au ruban

Inutile de vous dire qu'il est peu judicieux d'inscrire le code XML directement dans le code VBA. Si c'est le cas, les opérations de maintenance vont s'avérer très compliquées. Une méthode consiste à écrire les balises XML dans un fichier dédié, de lire ce fichier et de passer son contenu à la méthode LoadCustomUI. Dans cet exemple, le fichier en question sera nommé evenement_ribbon.XML et sa lecture se fera via l'objet FileSystemObjet de la librairie Microsoft Scripting Runtime. Vous devez donc l'ajouter à votre projet.

Il est conseillé de donner un nom explicit au fichier. Ceci vous facilitera les corrections futures. Dans le même ordre d'idée, il est préférable de stocker le fichier XML dans le même répertoire que l'application qui l'utilise.

Créez un nouveau module : mduRibbon.

Public Function LoadRibbon()
Dim strXML As String
Dim oFso As New FileSystemObject
Dim oFtxt As TextStream
'Charge le fichier XML en mémoire
Set oFtxt = oFso.OpenTextFile(CurrentProject.Path & _
      "\evenement_ribbon.XML", ForReading)
'Récupère le contenu
strXML = oFtxt.ReadAll
'Charge le rubban personnalisé correspondant
Application.LoadCustomUI "rubanperso", strXML
End Function

Le fichier XML à utiliser est très simple :

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon startFromScratch="true">
      <tabs>
         <tab id="tabEvenement" label="Gestion des événements" visible="true">
         <group id="grpEnregistrement" label="Enregsitrements">
             <button id="btnEssai" label="Essai" size="large"/>
			</group>
         </tab>
      </tabs>
   </ribbon>
</customUI>

La propriété gérant le ruban se situe dans l'onglet Autres des propriétés du formulaire. Il s'agit d'ID de ruban personnalisé. A ce stade, aucune valeur n'est disponible :

Et pour cause, dans la section précédente, nous avons écrit une fonction VBA permettant de charger le ruban. Mais, cette fonction n'ayant pas été lancée, le ruban n'est pas encore disponible. Il vous faut l'exécuter. Une technique consiste à placer le curseur sur une de ses lignes et d'actionner la touche F5.

A présent la zone de liste propose la valeur rubanperso.

Sélectionnez-la, enregistrez et ouvrez le formulaire en mode visualisation. Le nouveau ruban apparaît.

Un problème se pose si on ferme la base de données et la ré-ouvre. Le ruban est déchargé. En toute logique, dans ce cas, le ruban personnalisé ne pourra pas être affiché avec le formulaire. La solution : charger le ruban à chaque démarrage de la base de données. Pour cela, il est possible de créer une macro nommée AutoExec dont la seule et unique action sera d'exécuter la fonction LoadRibbon() vue précédemment.

Reprenons l'exemple donné plus haut pour examiner en détail la syntaxe d'un ruban:

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon startFromScratch="true">
      <tabs>
         <tab id="tabEvenement" label="Gestion des événements" visible="true">
         <group id="grpEnregistrement" label="Enregsitrements">
             <button id="btnEssai" label="Essai" size="large"/>
			</group>
         </tab>
      </tabs>
   </ribbon>
</customUI>

Dans ce fichier XML, la balise ribbon définit un nouveau ruban personnalisé. La balise tabs représente la liste des onglets (par exemple : Accueil, Créer, Données Externes). Etant donné qu'il s'agit d'une liste, on retrouve la configuration suivante :

<tabs>
	<tab>
	</tab>
	<tab>
	</tab>
</tabs>

Où chaque élément tab représente un onglet. Viennent ensuite les groupes (group) de contrôles.

Et enfin, chaque groupe est composé de contrôles (control). Ici, le groupe Enregistrements possède un seul contrôle : un bouton.

Vous remarquerez que toutes les balises sont inclues dans la racine immuable :

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
</customUI>

La plupart des balises possèdent un attribut id. Il permet d'identifier le composant du ruban de manière unique. Les doublons d'id sont interdits.

Attention : il ne faut pas confondre la balise group avec la balise groups. groups représente la collection de groupes, group correspond à un groupe. Il en va de même pour toutes les collections de noeuds : leur nom est toujours pluriel.

Pour répondre à la problématique énoncée au début de ce tutoriel, le ruban va proposer un onglet (Gestion des événements) ainsi qu'un premier groupe de contrôles (Données).

Le code du fichier XML respecte logiquement la hiérarchie des différents éléments.

Etape 1 : balise CustomUI

A ne pas oublier. Pour que le fichier XML soit valide, la balise racine doit être :

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
</customUI>

Etape 2 : définition du ruban personnalisé

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon>
      
   </ribbon>
</customUI>

Etape 3 : avant d'ajouter l'onglet, il faut impérativement créer la liste d'onglets.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon>
      <tabs>
         
      </tabs>
   </ribbon>
</customUI>

Etape 4 : création de l'onglet Gestion des événements

Les attributs utilisés sont :

• id : nom de l'onglet
• label : titre qui sera affiché
• visible : l'onglet est visible

Résultat :

Le ruban personnalisé vient s'ajouter au ruban d'Access. Pour masquer les autres onglets prédéfinis, il faut utiliser l'attribut startFromScratch de la balise ribbon.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon startFromScratch="true">
      <tabs>
         <tab id="tabEvenement" label="Gestion des événements" visible="true">
           <group id="grpDonnees" label="Données">
         
</group>
         </tab>
      </tabs>
   </ribbon>
</customUI>

V-C-1. Les boutons▲

Eléments de base, les boutons permettent de lancer une action en réponse à leur clic. Dans le XML, ils sont définis par la balise <button>. Il existe deux types de boutons :

• Les boutons prédéfinis
• Les boutons personnalisés

Quelque soit le type du bouton, son attribut size permet de définir sa taille. Les choix possibles sont large et normal.

V-C-1-1. Les boutons prédéfinis▲

Lors de la création de barres de menu dans les versions antérieures, il était possible de reprendre à son compte des boutons fournis par Access (par exemple les boutons copier, couper, coller).

Avec le ruban, cette fonctionnalité est conservée. Pour insérer un bouton prédéfini, il faut inclure son identifiant dans la balise <button> via l'attribut idMso.

Par exemple, pour le bouton Coller :

XML

Sélectionnez

<button idMso=Paste>
</button>

L'identifiant Mso correspond au nom anglais du bouton de commande. Vous pouvez consulter la liste des identifiants Mso en annexe pour obtenir la plupart des commandes.

Dans l'application qui nous intéresse, il est possible de confier des tâches demandées aux boutons prédéfinis :

• Ajouter un nouvel enregistrement (idMso=GoToNewRecord)
• Supprimer un enregistrement (idMso=RecordsDeleteRecord)

Le code XML du groupe grpDonnees sera donc :

XML

Sélectionnez

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon startFromScratch="true">
      <tabs>
        <tab id="tabEvenement" label="Gestion des événements" visible="true">
			<group id="grpDonnees" label="Données">
			<button idMso="GoToNewRecord" size="normal"/>
			<button idMso="RecordsDeleteRecord" size="normal"/>
			</group>
        </tab>
      </tabs>
   </ribbon>
</customUI>

Résultat :

Ce n'est pas parce que l'on utilise un bouton prédéfini que l'on ne peut pas le personnaliser un minimum. Il est par exemple possible de modifier son intitulé afin de le rendre plus explicite.

XML

Sélectionnez

			<group id="grpDonnees" label="Données">
			<button idMso="GoToNewRecord" label="Nouvel événement" size="normal"/>
			<button idMso="RecordsDeleteRecord" label="Supprimer l'événement" size="normal"/>
			</group>

V-C-1-2. Les boutons personnalisés▲

Evidemment, le développeur ne peut pas se limiter aux actions offertes par les boutons inclus dans Access. La possibilité de créer ses propres boutons est donc primordiale. Pour créer un bouton personnalisé, il suffit de ne pas spécifier d'identifiant idMso et de le remplacer par un identifiant simple via l'attribut id.

XML

Sélectionnez

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> 
   <ribbon startFromScratch="true">
      <tabs>
        <tab id="tabEvenement" label="Gestion des événements" visible="true">
			<group id="grpDonnees" label="Données">
			
			<button idMso="GoToNewRecord" label="Nouvel événement" size="large"/>
			<button id="btnDupliquer" label="Dupliquer l'événement" size="normal"/>
			<button idMso="RecordsDeleteRecord" label="Supprimer l'événement" size="normal"/>
			</group>
        </tab>
      </tabs>
   </ribbon>
</customUI>

Résultat :

A ce stade, le bouton n'est lié à aucune procédure. Un clic dessus n'aura aucun effet. La gestion des événements est traitée ultérieurement dans ce tutoriel.

V-C-1-3. Images▲

Dans un bouton personnalisé, aucune image n'est affectée au bouton. Comme en témoigne l'aperçu d'écran ci-dessus, le rendu graphique est assez disgracieux. Bien entendu, il est possible d'y remédier.

L'insertion d'image dans un bouton peut se faire de deux manières :

• Utiliser l'image d'un bouton prédéfini d'Access
• Utiliser sa propre image

Méthode 1 :

En attribuant l'identifiant idMso d'un bouton prédéfini à l'attribut imageMso du bouton personnalisé, Access affiche l'image du bouton prédéfini sur le bouton personnalisé.

Par exemple :

XML

Sélectionnez

<button id="btnDupliquer" label="Dupliquer l'événement" imageMso="SynchronizeData" size="normal"/>

Méthode 2 :

Celle-ci est un peu plus complexe. En effet, pour que le bouton puisse afficher l'image, il faut qu'elle soit dans un format acceptable (taille, poids, etc.) par le gestionnaire de ruban d'Office.

Pour convertir l'image dans ce format, il faut utiliser Visual Basic et plus particulièrement les fonctions CallBack du ruban. Qu'est ce que sont ces fameux CallBack ? Ce sont des fonctions lancées lors du chargement du ruban.
Imaginez une fonction nommée getImageDupliquer appelée par le ruban à son ouverture et qui retourne une image compatible. Le ruban récupère l'image et l'affecte au bouton btnDupliquer. Bien entendu, la fonction en question doit répondre à un protocole strict, notamment en ce qui concerne ses paramètres pour pouvoir être comprise et exécutée par le ruban.

En VBA, la convention du ruban impose qu'il s'agisse en fait d'une procédure dont l'entête est le suivant :

VBA

Sélectionnez

Public Sub GetImageDupliquer(ByVal control As IRibbonControl, ByRef image)

Quand le ruban appelle la procédure, il lui transmet le bouton concerné dans le premier paramètre (ce qui pourra par exemple permettre des vérifications avant l'affectation de l'image) et récupère l'image dans le paramètre image. Bien que déclaré en Variant, le paramètre image est en fait un objet du type IPictureDisp. La méthode LoadPicture permet de créer un tel objet en fonction du chemin de l'image.

Voici un exemple de fonction getImageDupliquer à insérer dans le module mduRibbon :

VBA

Sélectionnez

Public Sub GetImageDupliquer(ByVal control As IRibbonControl, ByRef image)
Set image = stdole.LoadPicture(CurrentProject.Path & "\dupliquer.jpg")
End Sub

Le lien entre la procédure et le bouton se fait bien entendu dans le XML via l'attribut getImage du bouton.

XML

Sélectionnez

<button id="btnDupliquer" label="Dupliquer l'événement" getImage="getImageDupliquer" size="normal"/>

Le fait que la fonction getImageDupliquer soit à votre charge peut paraître lourd, toutefois, c'est un réel avantage. Il est ainsi possible d'écrire une procédure qui correspond à vos besoins, notamment une procédure générique utilisable par plusieurs boutons :

VBA

Sélectionnez

Public Sub GetImageBouton(ByVal control As IRibbonControl, ByRef image)
Select Case control.Id
    Case btnDupliquer:
        Set image = stdole.LoadPicture(CurrentProject.Path & "\dupliquer.jpg")
    Case btnInserer:
        Set image = stdole.LoadPicture(CurrentProject.Path & "\inserer.bmp")
End Select
End Sub

V-C-2. Les cases à cocher▲

Une case à cocher est définie dans le code XML avec la balise checkbox. Contrairement aux boutons, il n'est pas possible d'utiliser l'attribut size. Une telle utilisation provoquerait une invalidation de tout le ruban.

Dans la problématique suivie depuis le début du tutoriel, des cases à cocher peuvent être mises en place pour gérer le filtrage des événements.

C'est ainsi que peut naître le groupe grpFiltre dont le XML est :

XML

Sélectionnez

<group id="grpFiltre" label="Filtre">
<checkBox id="chkDate" label="Aujourd'hui"/>
<checkBox id="chkImportant" label="Important"/>
</group>

V-C-3. Le contrôle Gallery - tableau de boutons▲

Le contrôle Gallery permet d'afficher un composant disposant des boutons en lignes et en colonnes. Il ne s'agit pas d'un sous-menu car il n'est possible d'inclure que des boutons.

Un tel élément est codé dans le XML avec la balise <gallery>. Il est alors possible de spécifier le nombre de colonnes (columns) et de lignes (rows) utilisées pour répartir les différents contrôles. Chaque bouton du contrôle Gallery est un Item représenté par une balise <item>.

L'exemple suivant vient s'ajouter au groupe grpFiltre pour permettre à l'utilisateur d'appliquer un filtre sur le mois.

XML

Sélectionnez

<gallery id="galMois" label="Mois ..." columns="3" rows="4" getImage="getImageGalleryMois">
	<item id="it01" label="Janvier"/>
	<item id="it02" label="Février"/>
	<item id="it03" label="Mars"/>
	<item id="it04" label="Avril"/>
	<item id="it05" label="Mai"/>
	<item id="it06" label="Juin"/>
	<item id="it07" label="Juillet"/>
	<item id="it08" label="Août"/>
	<item id="it09" label="Septembre"/>
<item id="it10" label="Octobre"/>
<item id="it11" label="Novembre"/>
<item id="it12" label="Décembre"/>
</gallery>

Ici, les éléments (les mois) sont décrits dans le XML mais il est possible de construire le tableau dynamiquement. Tout comme la mise en place d'image sur un bouton, la construction dynamique d'un contrôle Gallery se fait à l'aide de fonctions CallBack.

Trois fonctions sont nécessaires :

• getItemCount : nombre de boutons
• getItemLabel : texte du bouton
• getItemImage : image du bouton

En VBA, ces CallBack doivent correspondre à la norme suivante :

• Sub getItemCount(control As IRibbonControl, ByRef count)
• Sub getItemLabel(control As IRibbonControl, index As Integer, ByRef label)
• Sub getItemImage(control As IRibbonControl, index As Integer, ByRef image)

Pour la liste de mois donnée plus haut, il est possible de créer dynamiquement les différents items.

VBA :

VBA

Sélectionnez

Sub getLabelMois(control As IRibbonControl, index As Integer, ByRef label)
    label = Format(DateSerial(2000, index + 1, 1), "mmmm")
End Sub
Sub getNBMois(control As IRibbonControl, ByRef count)
    count = 12
End Sub
Sub getImageMois(control As IRibbonControl, index As Integer, ByRef image)
    Set image = stdole.LoadPicture("E:\imagesCalendrier\cal" & index + 1 & ".gif")
End Sub
Sub getImageGalleryMois(control As IRibbonControl, ByRef image)
Set image = stdole.LoadPicture("E:\imagesCalendrier\cal1.gif")
End Sub

XML :

XML

Sélectionnez

<gallery id="galMois" label="Mois ..." columns="3" rows="4" getImage="getImageGalleryMois" 
getItemCount="getNBMois" getItemLabel="getLabelMois" getItemImage="getImageMois"/>

Le ruban n'accepte pas que des contrôles de commande mais aussi des zones de saisies. Il est ainsi possible d'utiliser des zones de texte et des zones de listes déroulantes.

V-D-1. Les zones de texte▲

Il aurait été légitime de penser qu'il s'agissait de TextBox. Malheureusement, il y a un piège, ce sont en fait des editBox. Le risque de confusion avec leurs homologues VBA est donc important, soyez attentif. Comme pour les autres contrôles, il est possible de définir une légende (label), à la différence près qu'elle ne serait pas placée dans la zone de texte mais sur son côté gauche.

Grâce à ces éléments, nous pouvons rajouter un groupe de recherche à notre ruban personnalisé.

XML

Sélectionnez

<group id="grpRecherche" label="Recherche multi-critères">
<editBox id="txtNum" label="Num :"/>
<editBox id="txtDesc" label="Desc :"/>
<editBox id="txtDate" label="Date :"/>
</group>

Bien entendu, il est possible d'affecter dynamiquement du texte à une zone grâce à sa fonction CallBack getText.

Exemple :

Dans le module :

VBA

Sélectionnez

Sub getTextDate(control As IRibbonControl, ByRef text)
text = Format(Date, "dd/mm/yyyy")
End Sub

Dans le XML :

XML

Sélectionnez

<editBox id="txtDate" label="Date :" getText="getTextDate"/>

L'attribut sizeString de la zone de texte définit sa largeur. Elle est exprimée en nombre de caractères. L'attribut maxLength correspond au nombre de caractères maximum autorisés à la saisie.

V-D-2. Les zones de listes déroulantes▲

Là, le nom coïncide bien avec celui des zones de listes déroulantes VBA, à savoir comboBox. Comme pour le contrôle Gallery, les éléments sous-jacents sont définis dans des balises item.

Exemple :

XML

Sélectionnez

<comboBox id="cmbNum" label="Num :">
	<item id="itNum1" label="1"/>
	<item id="itNum2" label="2"/>
	<item id="itNum3" label="3"/>
</comboBox>

Les éléments peuvent aussi être créés dynamiquement. Prenons l'exemple donné plus haut qui consiste à proposer la liste des numéros d'événements.

VBA

Sélectionnez

Private oRst As DAO.Recordset


Sub getNBNum(control As IRibbonControl, ByRef count)
    Set oRst = CurrentDb.OpenRecordset("SELECT NumEvenement FROM tblevenement ORDER BY NumEvenement")
    'Récupère le nombre d'enregistrements
With oRst
        .MoveLast
        count = .RecordCount
        .MoveFirst
    End With
End Sub

Sub getNumLabel(control As IRibbonControl, index As Integer, ByRef label)
On Error GoTo err
    With oRst
        label = .Fields("NumEvenement")
        .MoveNext
    End With
Exit Sub
err:
MsgBox err.Description
End Sub

Ci-dessous, le code XML permettant de mettre en place ce comportement.

XML

Sélectionnez

<comboBox id="cmbNum" label="Num :" getItemCount="getNBNum" getItemLabel="getNumLabel"/>

Analysons en détail le code VBA. La variable oRst est déclarée au niveau du module. La méthode getNBNum (destinée à compter le nombre d'items à créer) est lancée en premier par le ruban. Elle instancie le recordset stocké dans la variable privée du module. La méthode getNumLabel n'a plus qu'à parcourir le recordset (disponible, puisque déclaré dans le module) pour retourner le numéro de l'événement (champ NumEvenement).

Autre type de contrôle disponibles : les séparateurs. Ce sont des barres verticales divisant deux groupes de boutons. La balise XML permettant de les identifier est <separator>. Ces composants n'affichant rien, le seul attribut à valoriser est l'identifiant (id).

Exemple :

<separator id="sepRecherche"/>

Le groupe de recherche devient alors :

<group id="grpRecherche" label="Recherche multi-critères">
<comboBox id="cmbNum" label="Num :" getItemCount="getNBNum" getItemLabel="getNumLabel"/>
<editBox id="txtDesc" label="Desc :"/>
<editBox id="txtDate" label="Date :"/>
<separator id="sepRecherche"/>
<button id="btnRechercher" label="Rechercher" imageMso="FindDialog" size="large"/>
</group>

Il s'agit des éléments qui nécessitent un clic pour déclencher leur action. On y retrouve les boutons, les cases à cocher ainsi que le contrôle Gallery. Le nom de la procédure qu'ils doivent lancer est inscrit dans leur attribut onAction. Pour que l'événement soit déclenché correctement, la procédure (CallBack) doit répondre à une nomenclature précise dépendante du type de contrôle.

VI-A-1. Les boutons▲

La procédure événementielle onAction d'un bouton doit correspondre à la syntaxe suivante :

VBA

Sélectionnez

Sub onAction(ByVal control As IRibbonControl)

L'argument control de la procédure représente le contrôle à l'origine du traitement.

Prenons le couple VBA/XML qui suit.

VBA

Sélectionnez

Public Sub btnDupliquer_action(ByVal control As IRibbonControl)
    MsgBox "Vous avez cliqué sur le bouton " & control.Id
End Sub

XML

Sélectionnez

<button id="btnDupliquer" label="Dupliquer l'événement" 
imageMso="SynchronizeData" size="normal" onAction="btnDupliquer_action"/>

Un clic sur le bouton Dupliquer l'enregistrement provoque l'affichage de la boîte de dialogue ci-dessous.

Pour revenir au projet qui nous intéresse depuis le début de ce tutoriel, et plus particulièrement la duplication de l'enregistrement, le code de la méthode btnDupliquer_action pourrait être :

VBA

Sélectionnez

Public Sub btnDupliquer_action(ByVal control As IRibbonControl)
    Dim strNom As String, bolImp As Boolean
    Dim oFrm As Form
    'Interroge l'utilisateur
    If MsgBox("Voulez-vous dupliquer cette événement aujourd'hui ?", vbYesNo + vbQuestion, "Dupliquer ?") = vbYes Then
        'Accède au formulaire
        Set oFrm = Forms("frmEvenement")
        With oFrm.Recordset
            'Récupère le nom de l'événement sélectionné
            strNom = .Fields("NomEvenement")
            bolImp = .Fields("Important")
            'Crée le nouvel enregistrement
            .AddNew
            .Fields("NomEvenement") = strNom
            .Fields("DateEvenement") = Date
            .Fields("Important") = bolImp
            .Update
        End With
    End If
    
End Sub

VI-A-2. Les cases à cocher▲

La procédure événementielle des cases à cocher est analogue à celle des boutons à la différence prés qu'un paramètre supplémentaire est nécessaire. Il permet de savoir si la case est cochée ou pas.

La norme définit l'entête suivant à appliquer :

VBA

Sélectionnez

Sub onAction(ByVal control As IRibbonControl, pressed As Boolean)

Le filtrage des événements de notre projet sur la date et leur importance peut être obtenu par :

XML

Sélectionnez

<checkBox id="chkDate" label="Aujourd'hui" onAction="chkDate_action"/>
<checkBox id="chkImportant" label="Important" onAction="chkImp_action"/>

VBA

Sélectionnez

Public Sub chkDate_action(ByVal control As IRibbonControl, pressed As Boolean)

    'mémorise la valeur de la case à cocher
    bolFiltreDate = pressed
    'Applique le filtre
    AppliquerFiltre
End Sub
Public Sub chkImp_action(ByVal control As IRibbonControl, pressed As Boolean)

    'mémorise la valeur de la case à cocher
    bolFiltreImp = pressed
    'Applique le filtre
    AppliquerFiltre
End Sub

Private Sub AppliquerFiltre()
    Dim oFrm As Form
    Dim strFiltre As String
    'Accède au formulaire
    Set oFrm = Forms("frmEvenement")
    'Construit le filtre
    If bolFiltreDate Then
        strFiltre = "DateEvenement=Date()"
    End If
    'Tiens compte du filtre sur Important
    If bolFiltreImp Then
        strFiltre = strFiltre & IIf(strFiltre <> "", " AND ", "") & "Important"
    End If
    'Affecte le filtre au formulaire
    oFrm.Filter = strFiltre
    oFrm.FilterOn = True
End Sub

Où bolFiltreDate et bolFiltreImp sont déclarées en entête de module par :

VBA

Sélectionnez

Private bolFiltreDate As Boolean
Private bolFiltreImp As Boolean

Comme vous avez pu le remarquer, les procédures chkDate_action et chkImp_action sont identiques. Si vous le souhaitez, vous pouvez les réunir :

VBA

Sélectionnez

Public Sub chkDateImp_action(ByVal control As IRibbonControl, pressed As Boolean)
    'Quel bouton ?
    Select Case control.Id
        Case "chkDate": bolFiltreDate = pressed
        Case "chkImp": bolFiltreImp = pressed
    End Select
    'Applique le filtre
    AppliquerFiltre
End Sub

Ce qui donne dans le XML :

XML

Sélectionnez

<checkBox id="chkDate" label="Aujourd'hui" onAction="chkDateImp_action"/>
<checkBox id="chkImp" label="Important" onAction="chkDateImp_action"/>

VI-A-3. Le contrôle Gallery▲

Sub onAction(ByVal control As IRibbonControl, selectedId As String, selectedIndex As Integer)

Public Sub galMois_action(ByVal control As IRibbonControl, _
    selectedId As String, selectedIndex As Integer)
    Dim oFrm As Form
    Dim strFiltre As String
    'Accède au formulaire
    Set oFrm = Forms("frmEvenement")
    strFiltre = "Month(DateEvenement)=" & selectedIndex + 1
    'Affecte le filtre au formulaire
    oFrm.Filter = strFiltre
    oFrm.FilterOn = True
End Sub

<gallery id="galMois" label="Mois ..." columns="3" rows="4" 
getImage="getImageGalleryMois" getItemCount="getNBMois" getItemLabel="getLabelMois" getItemImage="getImageMois" onAction="galMois_action"/>
</group>

Qu'ils s'agissent de zones de texte ou bien de zones de listes déroulantes, la procédure événementielle est la même. Nommée onChange, elle se déclenche lorsque l'utilisateur valide sa saisie (changement de contrôle, appui sur la touche Entrée). Son entête est défini comme suit :

Sub onChange(ByVal control As IRibbonControl, text As String)

Exemple :

Public Sub cmbNum_change(ByVal control As IRibbonControl, text As String)
    MsgBox "Valeur de " & control.Id & ":" & text
End Sub

<comboBox id="cmbNum" label="Num :" getItemCount="getNBNum" getItemLabel="getNumLabel" onChange="cmbNum_change"/>

Le code à appliquer aux contrôles cmbNum, txtDesc et txtDate est similaire à celui des cases à cocher du groupe Filtre. Je ne vais donc pas rentrer plus en détails. Il s'agit d'une simple recherche multi-critères dont le tutoriel de Cafeine constitue un bon exemple.

L'objet Access.Application ne fournit pas de méthode permettant d'accéder à un élément du ruban. En fait, rien ne permet d'agir directement sur un attribut de celui-ci. La seule solution disponible est de lui demander d'aller lui même chercher les informations dont il a besoin. Grâce à des fonctions nommées getXXX, le ruban est capable de rafraîchir sa propriété XXX. Vous vous en doutez, cela passe une nouvelle fois par des fonctions CallBack. La mise au point d'un tel système passe par deux étapes :

• Au chargement, il faut instancier un objet correspondant au ruban. Cet objet déclaré dans un module sera accessible partout dans l'application.
• Appeler la méthode de rafraîchissement du ruban (ou d'un de ses contrôles) au moment voulu.

VII-A-1. Mémorisation du ruban dans un objet▲

Sub getMonRuban(ribbon As IRibbonUI)
Set oMonruban = ribbon
End Sub

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" onLoad="getMonRuban"> 
...
...
</customUI>

VII-A-2. Rafraîchissement du ruban▲

Comme indiqué dans l'énoncé, il ne doit pas être possible de supprimer un événement important. Le bouton doit donc être inactif dans ce cas. La propriété gérant cet état est nommée enabled. L'attribut définissant la fonction CallBack modifiant cette propriété est donc getEnabled.

Ce qui donne :

<button idMso="RecordsDeleteRecord" label="Supprimer l'événement" 
size="normal" getEnabled="getBtnSupprimer_enabled"/>

Sub getBtnSupprimer_enabled(control As IRibbonControl, ByRef enabled)
On Error GoTo err:
    Dim oFrm As Form
    'Accède au formulaire
    Set oFrm = Forms("frmEvenement")
    enabled = Not oFrm.Recordset.Fields("Important").Value
    Exit Sub
err:
'en cas d'erreur, rendre la suppression impossible
enabled = False
End Sub

Cependant, il n'est pas possible de modifier le comportement d'un bouton prédéfini. Il faut donc remplacer le bouton DeleteRecord2 par un bouton personnalisé :

<button id="btnSupprimer" label="Supprimer l'événement" 
size="normal" getEnabled="getBtnSupprimer_enabled" onAction="btnSupprimer_action" imageMso="DeleteRecord2"/>

Il ne reste plus qu'à demander le rafraîchissement du bouton lorsque l'utilisateur change d'enregistrement. Cela passe par une procédure événementielle sur l'événement Current (Sur Activation) du formulaire.

Private Sub Form_Current()
If Not (oMonruban Is Nothing) Then
oMonruban.InvalidateControl "btnSupprimer"
End If
End Sub

Le test Not (oMonruban Is Nothing) permet d'éviter d'éventuelles erreurs au cas où le ruban ne serait pas chargé.

Dans notre exemple, le fait de filtrer par mois doit réinitialiser les deux cases à cocher. En effet, le filtrage avec les cases à cocher et celui avec le contrôle Gallery sont indépendants. L'attribut définissant la valeur d'une case à cocher est pressed, il est donc nécessaire d'implémenter la fonction CallBack getPressed.

Sub getchkDateImp_pressed(control As IRibbonControl, ByRef pressed)
    'Quel bouton ?
    Select Case control.Id
        Case "chkDate":  pressed = bolFiltreDate
        Case "chkImp":  pressed = bolFiltreImp
    End Select
End Sub

<checkBox id="chkDate" label="Aujourd'hui" onAction="chkDateImp_action" getPressed="getchkDateImp_pressed"/>
<checkBox id="chkImp" label="Important" onAction="chkDateImp_action" getPressed="getchkDateImp_pressed"/>

Reste à définir le moment où les cases à cocher doivent être rafraîchies. Réponse : lorsque l'utilisateur utilise le contrôle Gallery.

Il faut donc rajouter ces quelques lignes à la procédure galMois_action :

'Vide les cases à cocher
    bolFiltreDate = False
    bolFiltreImp = False
    oMonruban.InvalidateControl "chkDate"
    oMonruban.InvalidateControl "chkImp"

Il est possible de modifier n'importe quelle propriété d'un contrôle via une procédure de rappel getXXX où XXX est le nom de la propriété en question. La liste des fonctions Callback est disponible dans l'annexe B.