Comment personnaliser le Ruban de Word 2007

Les onglets permettent le regroupement de certaines commandes. Le nom anglais des onglets est "Tab". Les onglets possèdent une étiquette, c'est elle qui est affichée.

Les groupes constituent un regroupement supplémentaire dans un onglet.
Un groupe possède une étiquette.
Certains groupes possèdent un lanceur de boîte de dialogue.

1. Étiquette de l'onglet
2. Groupe
3. Lanceur de boîte de dialogue
4. Description de la boîte de dialogue (elle donne un aperçu rapide du contenu de la boîte de dialogue)

Les onglets sont donc structurés en groupes et les groupes contiennent les commandes. On les retrouve sous forme de boutons, cases à cocher, listes déroulantes, liste modifiables, ...

• 2 Les boutons simples qui ont un effet immédiat
• 1 et 3 Des boutons qui vont ouvrir une liste déroulante.

Dans l'exemple précédent, nous avons ouvert un fichier qui possédait déjà un onglet personnalisé. Nous allons maintenant faire le test avec un document créé de toute pièce.
Notre première étape sera la création d'un nouveau document vierge. Je vous propose de créer un document "TestRuban2.docm", que nous allons utiliser immédiatement.

A l'aide du bouton ouvrir (1), nous ouvrons une boîte de dialogue qui n'affiche que les fichiers Office. Choisissons notre fichier "TestRuban2.docm". Ce fichier ne contient pas de fichier de modification du ruban, la fenêtre est vide.

C'est bien notre fichier qui est ouvert.

À l'aide du menu Sample, nous allons ajouter un fichier XML à notre document.

J'ai triché un peu, le fichier XML que nous avons utilisé plus haut a été copié dans le répertoire "C:\Program Files\CustomUIEditor\Samples" sous le nom Onglet En plus.xml. C'est la raison de la présence d'un fichier en plus des fichiers fournis.

Une fois de plus, nous voilà en terrain conquis.
Je pense que les autres commandes ne seront pas plus compliquées.

Une commande très intéressante est la commande permettant d'ajouter une icone à votre bouton. Il est en effet possible de créer vos propres icônes. Le programme autorise l'utilisation des images jpeg.

Lors de la sauvegarde, le fichier XML est directement implanté dans le document et les liens sont ajoutés au fichier .rels .

Attention, l'implémentation d'un fichier XML dans un document efface le contenu du document !

Le bouton est l'objet le plus simple de la "collection".

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="false" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<button id="but01" label="Bouton01" size="large" screentip="mon texte"/>
					<button id="but02" label="Bouton02" image="ange" />
				</group>
				<group id="Gp01" label="Groupe de course 01">
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Le résultat :

Passons en détail les différents attributs utilisés pour les boutons.

• id : Identification du bouton, doit être unique, mais vous avez le choix.
• label : Étiquette du bouton
• size : Taille du bouton, vous n'avez que deux possibilités, normal ou large
• screentip : Texte qui va s'afficher lorsque vous allez survoler le contrôle avec la souris
• image : Image qui sera affichée sur votre bouton

On peut également citer les imageMso qui sont des images déjà contenues dans les applications et qui peuvent être utilisées dans vos boutons.

<button id="but03" label="Avec image MSO" imageMso="AcceptInvitation"/>

Le nom des images MSO se trouve dans les classeurs que vous pouvez télécharger avec les liens ci-dessous.

Dans tous les boutons, nous avons omis la déclaration de la procédure à utiliser.

<button id="but03" label="Avec image MSO" imageMso="AcceptInvitation" onAction="ThisDocument.MonAction"/>

Si vous ne spécifiez pas l'attribut onAction, un clic sur le bouton ne lève pas d'erreur.

Ces boutons possèdent deux états, normal ou enfoncé. Ils possèdent deux caractéristiques intéressantes, la première est que l'on peut activer une procédure sur le onAction du bouton, et la seconde est que l'état du bouton peut être récupéré.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<button id="but01" label="Bouton01" size="large" screentip="mon texte"/>
					<button id="but02" label="Bouton02" image="ange" size="large" />
					<button id="but03" label="Avec image MSO" imageMso="AcceptInvitation" 
					         onAction="MacroRuban.MonAction"/>
				</group>
				<group id="Gp01" label="Groupe de course 01">
					<toggleButton id="togl01" label="Bouton à bascule" getPressed="Enfonce" 
					        onAction="MacroRuban.Bascule"/>
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Et dans le document :

Sub Bascule(control As IRibbonControl, Enfonce As Boolean)
If Enfonce Then
    MsgBox "Bouton enfoncé !"
Else
    MsgBox "Bouton relâché !"
End If
End Sub

Si nous revenons à notre document, lors d'une action sur le bouton à bascule, nous allons déclencher une procédure et l'état du bouton sera pris en compte. L'état du bouton est renvoyé par la variable "Enfonce". Variable que l'on retrouve dans notre code et dans le XML du bouton avec l'attribut getPressed.

On peut aussi utiliser ce changement d'état pour affecter une valeur à une variable qui pourra être utilisée dans une procédure.

Option Explicit
'Déclaration d'une variable booléenne
Dim MaVal As Boolean

Sub monAction(control As IRibbonControl)
	' Affichage de la valeur de ma variable
    MsgBox "Action sur bouton" & "  " & MaVal
    
End Sub


Sub Bascule(control As IRibbonControl, Enfonce As Boolean)
If Enfonce Then
	' Affichage d'un message sur action
	' et affectation d'une valeur
    MsgBox "Bouton enfoncé !"
    MaVal = True
    
Else
    MsgBox "Bouton relâché !"
    MaVal = False
End If
End Sub

On peut donc effectuer une action lors de l'utilisation d'un bouton, mais aussi affecter une valeur à une variable que l'on pourra réutiliser par la suite.

Le principe des cases à cocher est le même que pour les boutons à bascule.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon startFromScratch="true">
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp01" label="Groupe de course 01">
					<toggleButton id="togl01" label="Bouton à bascule" getPressed="Enfonce" 
					                   onAction="MacroRuban.Bascule"/>
					<checkBox id="chk01" label="Ma case à cocher" enabled="true" 
					                   onAction="MacroRuban.CaseACocher" />
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Le résultat :

Les zones de saisie sont des zones de texte qui permettent d'effectuer la saisie d'une valeur.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp01" label="Groupe de course 01">
					<toggleButton id="togl01" label="Bouton à bascule" getPressed="Enfonce" 
					                    onAction="MacroRuban.Bascule"/>
					<checkBox id="chk01" label="Ma case à cocher" enabled="true" 
					                    onAction="MacroRuban.CaseACocher" />
					<editBox id="ed01" label="Zone de saisie" maxLength="10" sizeString="aaaaa" tag="Donnee" 
					                    onChange="Changement"  />
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Avec le résultat :

• maxLength représente la longueur maximale de la chaîne
• sizeString représente la largeur du contrôle

Cette fois, j'ai utilisé la génération des Callbacks pour le code.

'Callback for ed01 onChange
Sub Changement(control as IRibbonControl, text as String)
End Sub

Et avec les actions qui doivent être prises :

'Callback for ed01 onChange
Sub Changement(control As IRibbonControl, text As String)
monTxt = text
MsgBox "Changé" & vbCrLf & text
End Sub

Le contenu du contrôle est dans la variable "text".

Les listes déroulantes sont des listBox dans lesquelles vous pouvez choisir une valeur parmi des valeurs existantes. Ces listes sont enrichies avec des éléments "Item".

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp01" label="Groupe de course 01">
					<toggleButton id="togl01" label="Bouton à bascule" getPressed="Enfonce" 
					                          onAction="MacroRuban.Bascule"/>
					<checkBox id="chk01" label="Ma case à cocher" enabled="true" 
					                          onAction="MacroRuban.CaseACocher" />
					<editBox id="ed01" label="Zone de saisie" maxLength="10" sizeString="aaaaa" tag="Donnee" 
					                          onChange="Changement"  />
					<dropDown id="list01" label="Ma Liste" tag="DeLaListe" 
					                          onAction="MacroRuban.ListeDerou" >
						<item id="it01" label="item 001" />
						<item id="it02" label="item 002" />
						
					</dropDown>
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Dans la construction du contrôle, on inclut la liste des éléments qui vont composer la liste. De cette liste, sur l'évènement onAction, nous pouvons récupérer soit l'id de l'élément soit son index.

'Callback for list01 onAction
Sub ListeDerou(control As IRibbonControl, id As String, index As Integer)
MsgBox id & vbCrLf & index

End Sub

La liste modifiable est un peu différente, alors que la liste déroulante impose le choix d'une valeur préexistante, la liste modifiable autorise la saisie d'un élément non présent dans la liste.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp01" label="Groupe de course 01">
					<toggleButton id="togl01" label="Bouton à bascule" getPressed="Enfonce" 
					                          onAction="MacroRuban.Bascule"/>
					<checkBox id="chk01" label="Ma case à cocher" enabled="true" 
					                          onAction="MacroRuban.CaseACocher" />
					<editBox id="ed01" label="Zone de saisie" maxLength="10" sizeString="aaaaa" 
					                          tag="Donnee" onChange="Changement"  />
					<dropDown id="list01" label="Ma Liste" tag="DeLaListe" 
					                          onAction="MacroRuban.ListeDerou" >
						<item id="it01" label="item 001" />
						<item id="it02" label="item 002" />
					</dropDown>
					<comboBox id="comb01" label="Mon combo" onChange="cmbOnChange" >
						<item id="it001" label="item 001" />
						<item id="it002" label="item 002" />
					</comboBox>
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Contrairement au contrôle listBox, le comboBox permet de récupérer le contenu du Label.

'Callback for comb01 onChange
Sub cmbOnChange(control As IRibbonControl, text As String)
MsgBox text

End Sub

Comme à chaque fois, une image :

Tous les id des éléments doivent être différents même s'ils appartiennent à des listes différentes.

Les éléments de liste ont été abordés plus tôt. Ils sont déclarés par les balises "Items", leurs id doivent être uniques, même si ces éléments appartiennent à des listes différentes.

<item id="it001" label="item 001" />
<item id="it002" label="item 002" />

Cette fonctionnalité va permettre de grouper des contrôles.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<buttonGroup id="bgr01" >
					<button id="BG01" label="lbl 01" />
					<button id="BG02" label="lbl 02" />
					<button id="BG03" label="lbl 03" />
					</buttonGroup>
					
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Et le résultat :

Les menus sont en réalité des déroulants contenant des commandes.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<splitButton id="SPL01" >
					<menu>
					<button id="SPB01" label="lbl 01" onAction="MacroRuban.BoutGroup1"/>
					<button id="SPB02" label="lbl 02 Dans menu" />
					<button id="SPB03" label="lbl 03" />
					</menu>
					</splitButton>
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

On peut ajouter des images qui vont figurer devant l'étiquette.

<button id="SPB03" label="lbl 03" image="ange"/>

Les étiquettes permettent d'afficher des informations dans votre ruban.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<labelControl id="lbl001" label="mon étiquette" />
					<buttonGroup id="bgr01" >
					<button id="BG01" label="lbl 01" onAction="MacroRuban.BoutGroup1"/>
					<button id="BG02" label="lbl 02" />
					<button id="BG03" label="lbl 03" />
					<toggleButton id="BG04" label="lbl 04" />

					</buttonGroup>
				</group>

			</tab>
		</tabs>
	</ribbon>
</customUI>

Nous allons aborder les lanceurs de boîtes de dialogue. Pour donner une touche professionnelle à vos rubans, c'est le détail qu'il faut ajouter !

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon>
		<tabs>
			<tab idMso="TabHome" visible="true" />
			<tab id="MyTab01" label="Mon Onglet" insertBeforeMso="TabInsert"> 
				<group id="Gp02" label="Groupe de course" tag="Mon Tag" >
					<labelControl id="lbl001" label="mon étiquette" />
					
 					<buttonGroup id="bgr01" >
					<button id="BG01" label="lbl 01" onAction="MacroRuban.BoutGroup1"/>
					<button id="BG02" label="lbl 02" />
					<button id="BG03" label="lbl 03" />
					<toggleButton id="BG04" label="lbl 04" />

					</buttonGroup>

					<splitButton id="SPL01" >
					<menu>
					<button id="SPB01" label="lbl 01" onAction="MacroRuban.BoutGroup1"/>
					<button id="SPB02" label="lbl 02 Dans menu" />
					<button id="SPB03" label="lbl 03" image="ange"/>
					</menu>

					</splitButton>
					<box id="box01">
					<button id="but01" label="Bouton01" size="large" screentip="mon texte"/>
					<button id="but02" label="Bouton02" image="ange" size="large" />
					<button id="but03" label="Avec image MSO" imageMso="AcceptInvitation" 
					                   onAction="MacroRuban.MonAction"/>
					</box>
			            <dialogBoxLauncher>
                  			<button id="lau01" label="Mon Lanceur" screentip="Mon lanceur." 
							            onAction="OnAction" />
               			</dialogBoxLauncher>
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

<dialogBoxLauncher>
		<button id="lau01" label="Mon Lanceur" screentip="Mon lanceur." onAction="OnAction" />
</dialogBoxLauncher>

Dernier morceau, la Barre d'outils Accès rapide. Cette barre d'outils est modifiable de la même manière que le ruban.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" >
	<ribbon startFromScratch="true">
      <qat> 
         <sharedControls> 
            <button idMso="Copy"  /> 
            <button idMso="Paste" /> 
         </sharedControls> 
      </qat>
	</ribbon>
</customUI>

Nous allons nous baser sur un document vide et spécifier que ce sera un modèle de document. Pour obtenir la boîte de dialogue qui suit, dans les différents choix proposés par Word, nous allons utiliser "Mes Modèles" .

Nous obtenons un document totalement vide basé sur le Normal.dotm. Ce modèle, nous allons le sauvegarder dans un répertoire quelconque du disque dur jusqu'à ce qu'il soit terminé. Une fois terminé, nous allons placer ce modèle dans C:\Documents and Settings\UserName\Application Data\Microsoft\Word\STARTUP. Il deviendra alors disponible en permanence et semblera faire partie de l'interface normale de Word 2007.

Nous allons le placer dans l'onglet Accueil qui est TabHome. Ensuite nous allons ajouter un groupe qui portera le nom de : Changer de Document et finalement, nous allons ajouter à ce groupe une liste déroulante Documents Ouverts

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" onLoad="ChargerRuban">
	<ribbon>
		<tabs>
			<tab idMso="TabHome">
				<group id="SwitchDocuments" label="Changer de Document" 
				            insertAfterMso="GroupIllustrations">
					<dropDown id="listDocs" label="Documents Ouverts" tag="DeLaListe" 
							onAction="ListeDocs" getItemCount="NbreElement" getItemLabel="AjoutTexte"  >
						
					</dropDown>					
					
				</group>
			</tab>
		</tabs>
	</ribbon>
</customUI>

Comme vous l'avez probablement remarqué, la liste ne contient pas d'éléments. Nous allons remplir cette liste de manière dynamique. Pour remplir la liste, deux méthodes sont utilisées : getItemCount et getItemLabel. Ces deux méthodes sont liées à deux procédures qui seront utilisées pour obtenir le nombre d'éléments qui va alimenter la liste et le texte des éléments qui va être utilisé pour construire la liste.

'Callback for listDocs getItemCount
Sub NbreElement(control As IRibbonControl, ByRef returnedVal)
'Nous allons utiliser le nombre de documents contenus dans la 
'collection des documents ouverts
returnedVal = Documents.Count

End Sub

En fonction du nombre d'éléments que va contenir la liste, Word va "boucler" la procédure getItemLabel pour construire la liste.

'Callback for listDocs getItemLabel
Sub AjoutTexte(control As IRibbonControl, index As Integer, ByRef returnedVal)
Dim i As Integer

returnedVal = Documents(index + 1).Name

End Sub

L'étape suivante est le basculement dans Word du document choisi.

onAction="ListeDocs"

Dans notre XML, nous avons déterminé que lorsque la liste déroulante serait mise à jour, la procédure listDocs serait exécutée.

'Callback for listDocs onAction
Sub ListeDocs(control As IRibbonControl, id As String, index As Integer)
'Activation du document choisi

Documents(index + 1).Activate

End Sub

Dans le code, vous aurez probablement remarqué que nous ajoutons 1 à l'index renvoyé par la liste. La raison est assez simple, l'index de la liste commence à 0 alors que l'index des documents commence à 1. Le simple fait d'ajouter 1 corrige cet écart.
Lorsque vous choisirez un document dans la liste, ce dernier sera automatiquement activé et passera au premier plan.

Le souci que nous rencontrons maintenant est bloquant, la liste n'est mise à jour que lors du chargement du modèle, si nous chargeons un autre document ou changeons de document, le liste n'est plus mise à jour.

Pour mettre la liste à jour lors de chaque changement, nous allons faire appel aux évènements de l'application Word. L'évènement qui sera le plus approprié est Document_Change qui se produit lors de chaque changement de document.

Pour permettre à Word de réagir face à certains évènements, nous allons ajouter à notre projet un module de classe.

Nous allons renommer ce module en "EventClassModule".

Nous allons ajouter un peu de code pour permettre à Word d'utiliser l'évènement qui nous intéresse.

Public WithEvents wApp As Word.Application


Private Sub wApp_DocumentChange()
'Si votre code fonctionne, vous aurez une boite de message
MsgBox "Document changé "
End Sub

Pour faire fonctionner ce code, nous avons encore besoin d'une ou deux petites choses. Il faut activer la prise en compte des évènements lors du chargement du document. Nous allons ajouter un morceau de code dans le module "ThisDocument".

Dim X As New EventClassModule

Private Sub Document_Open()
    Set X.wApp = Word.Application
End Sub

Sans ces quelques lignes les évènements ne seront pas pris en compte.

Pour vérifier que notre évènement est pris en compte, nous allons utiliser une boite de message qui sera affichée lors de chaque changement de document. Cette boite de message sera enlevée par la suite.

Avec cette procédure, nous avons le moyen d'appeler un autre code qui mettra notre Ruban à jour.

Public WithEvents wApp As Word.Application

Private Sub wApp_DocumentChange()
MettreAJour
'MsgBox "Document changé du complément"
End Sub

Avec le même principe que pour le module de classe, nous allons ajouter à notre projet un simple module qui contiendra les procédures pour la mise à jour du Ruban. Pour pouvoir mettre le Ruban à jour, il faut le charger dans notre module. Dans le XML, nous avons spécifié que sur l'action OnLoad du Ruban, nous exécutions une procédure.

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

Cette procédure sera : "ChargerRuban". Nous allons l'ajouter dans notre module.

Dim monRub As IRibbonUI

Public Sub ChargerRuban(ribbon As IRibbonUI)
Set monRub = ribbon

End Sub

Cette procédure permet d'initialiser une variable : monRub qui est un objet Ruban et qui reste disponible hors de la procédure.

L'étape suivante reste la mise à jour du ruban lorsque l'on change de document. Si cette mise à jour n'est pas faite, la liste devient erronée et ne peut par conséquent plus être utilisée.

Public Sub MettreAJour()
monRub.InvalidateControl "listDocs"
monRub.Invalidate


End Sub

Cette procédure qui va redessiner le ruban est appelée lors de chaque changement de document.

Private Sub wApp_DocumentChange()
MettreAJour
'MsgBox "Document changé du complément"
End Sub

Ce code n'est que le rappel du code déjà cité plus haut.

Notre document est prêt pour être utilisé en tant que modèle.

si vous copiez ce modèle dans le répertoire : C:\Documents and Settings\user\Application Data\Microsoft\Word\STARTUP, ses fonctionnalités seront disponibles pour tous les documents Word, il fonctionnera comme un complément.