Boîtes de dialogue personnalisées sous Office (Excel, Word…)

VBA fournit deux boîtes de dialogue : MsgBox et InputBox.
La première pour afficher un message et demander un choix à l'utilisateur (oui, non, annuler…).
La deuxième pour demander la saisie d'un texte.

Ces deux boîtes sont très limitées.
Il n'est par exemple pas possible de modifier la police de caractères ou les couleurs.
On ne peut pas non plus limiter la saisie avec un masque de saisie ou proposer un choix avec une liste de valeurs.

La solution pour proposer un dialogue plus ergonomique et sécurisé est de créer soi-même des boîtes de dialogue avec des UserForms.

Pour plus d'information sur les UserForms, consultez ce tutoriel :
Utiliser les UserForm en VBA Excel.

Créez un nouvel UserForm (Insertion => UserForm dans l'éditeur VBA (ALT + F11)) et nommez-le frmDiagInput1.

Après la création de ce UserForm, vérifiez dans ses propriétés que celui-ci est bien modal :

Le UserForm créé est totalement vierge.

Comme il est défini en fenêtre modale, on ne peut pas cliquer ailleurs que dans ce UserForm tant qu'il n'est pas fermé.

Sur ce UserForm vierge, ajoutez les contrôles (Affichage => Boîte à Outils) nécessaires à la boîte de dialogue.

Nous allons commencer par une simple boîte semblable à une InputBox avec :

• une étiquette lblMessage qui contient le texte d'information ;
• une zone de texte txtInput qui contient la saisie de l'utilisateur ;
• deux boutons de commande btnOK et btnCancel pour respectivement valider ou annuler la saisie.

Vous pouvez bien sûr personnaliser la boîte de dialogue en modifiant par exemple la couleur de fond et les polices de caractères (du texte d'information, du texte de saisie ou des textes des boutons).

Mettez la zone de texte txtInput en premier contrôle dans l'ordre de tabulation (menu Affichage => Ordre de tabulation) pour que ce contrôle soit actif à l'ouverture du UserForm.

Dans ce chapitre, nous allons utiliser des variables globales.
Dans le chapitre suivant, nous aborderons une méthode plus robuste et plus souple.

Créez un module standard :

• dans l'éditeur VBA (ALT + F11) ;
• dans le menu : Insertion => Module.

Dans ce module on va créer une fonction qui ouvre notre UserForm de dialogue.

Function TestDialog1()
' Ouverture du UserForm en mode modal (défini dans les propriétés du UserForm)
frmDiagInput1.Show
End Function

Le UserForm a été créé avec la propriété ShowModal à Vrai, ce qui permet d'attendre que leUserForm soit fermé avant de continuer l'exécution du code.

Mais lorsque la procédure reprend, le UserForm est fermé et donc on ne peut plus lire la valeur saisie.

Pour pouvoir dialoguer entre la procédure appelante et le UserForm, on peut utiliser des variables globales.

Dans un nouveau module standard, que nous nommerons par exemple ModDialog, on définit trois variables :

Public gDiagCaption As String ' Titre de la fenêtre
Public gDiagValeur As String ' Valeur saisie
Public gDiagOK As Boolean ' Valeur validée

Ces variables sont publiques pour pouvoir être lues ou modifiées à la fois depuis la procédure appelant le UserForm de dialogue et depuis ce UserForm.

Avant d'ouvrir le UserForm, il est nécessaire d'initialiser ces variables :

' Initialisation des variables
gDiagCaption = "Ma fenêtre de saisie"
gDiagValeur = "Valeur par défaut"
gDiagOK = False

Ensuite, dans le UserForm, il faut gérer ces variables.

Ajoutez une procédure sur initialisation du UserForm :

• en haut à gauche de la page de code, choisir UserForm ;
• puis à droite, choisir Initialize ;

Dans la procédure qui est créée, on ajoute le code à exécuter à l'ouverture du UserForm :

1. Mise à jour du titre de la fenêtre ;
2. Mise à jour de la valeur saisie par défaut.

Private Sub UserForm_Initialize()
Me.Caption = gDiagCaption ' Titre
Me.txtInput.Value = gDiagValeur ' Valeur par défaut
End Sub

Puis on gère les clics sur les boutons (évènement Click de chaque bouton à choisir dans les listes déroulantes en haut de la page de code :

Pour le bouton « Valider » (btnOK) :

• on met à jour la variable gDiagValeur avec la valeur contenue dans la zone de saisie (avec Nz pour gérer la valeur Null) ;
• on met le flag gDiagOK à Vrai, ce qui indiquera à la procédure appelante qu'on a validé la saisie ;
• on ferme le UserForm.

Pour le bouton « Annuler » (btnCancel) :

• on vide la variable gDiagValeur ;
• on ferme le UserForm.

' Sur clic sur Valider
Private Sub btnOK_Click()
gDiagValeur = Nz(Me.txtInput.Value) ' Valeur de la zone de texte
gDiagOK = True ' Flag OK
Unload Me  ' Ferme le UserForm
End Sub
            
' Sur clic sur Annuler
Private Sub btnCancel_Click()
gDiagValeur = "" ' Pas de valeur retournée
Unload Me  ' Ferme le UserForm
End Sub

Il est enfin facile de récupérer les valeurs de ces trois variables dans la procédure appelante.

Function TestDialog1()
' Initialisation des variables
gDiagCaption = "Ma fenêtre de saisie"
gDiagValeur = "Valeur par défaut"
gDiagOK = False
' Ouverture du UserForm en mode modal
frmDiagInput1.Show
' Test de la saisie
If gDiagOK Then
    ' si gDiagOK = True alors gDiagValeur contient la valeur saisie et validée
    MsgBox "Valeur saisie : " & gDiagValeur
Else
    ' si gDiagOK = False alors gDiagValeur est vide, la saisie a été annulée
    MsgBox "Saisie annulée"
End If
End Function

Si vous essayez de lire une valeur du UserForm après sa fermeture (par exemple frmDiagInput1.txtInput.Value), cela va recharger un nouveau UserForm et renvoyer la valeur par défaut.

Attention à l'utilisation de variables globales.
Si elles ne sont pas correctement (et toutes) initialisées, cela peut entraîner des bogues dans le déroulement du traitement.

La méthode utilisée dans ce chapitre permet de se passer de variables globales.

On peut également ouvrir des boîtes de dialogue en cascade en utilisant le même UserForm.

L'appel de boîte de dialogue en cascade est un cas particulier.
Dans le cas général on préférera créer une boîte de dialogue qui regroupe plusieurs textBox de saisie par exemple.

Créez un UserForm frmDiagInput2 comme expliqué dans le chapitre  Création d'un UserForm pour une boîte de dialogue.

Dans une nouvelle fonction, on crée un nouvel objet de type frmDiagInput2.

Function TestDialog2()
' Création du UserForm
With New frmDiagInput2
 .Show
End With
End Function

L'utilisation de With…End With est très pratique, car il n'est alors pas nécessaire de rappeler le nom de l'objet à chaque appel de méthode ou propriété.

Si vous n'avez pas l'habitude de cette instruction, l'équivalent avec la déclaration d'un objet est :

Function TestDialog2()
Dim loForm as frmDiagInput2  
Set loForm = New frmDiagInput2
loForm.Show
Set loForm = Nothing
End Function

Notez qu'un UserForm créé de cette manière avec New n'est pas visible par défaut.
Il faut appeler sa méthode Show pour qu'il soit affiché.
Cela permet de faire des modifications sur le UserForm avant de l'afficher, par exemple :

Function TestDialog2()
' Création du UserForm
With New frmDiagInput2
    ' Titre de la fenêtre
    .Caption = "Ma saisie personnalisée"
    ' Message dans l'étiquette
    .lblMessage.Caption = "Veuillez saisir une valeur..."
    ' Valeur par défaut dans la zone de texte
    .txtInput.Value = "Valeur par défaut"
    ' Rend visible le UserForm
    .Show
End With
End Function

Lorsqu'on appelle la méthode Show pour afficher le UserForm (de type Modal), la procédure appelante est mise en attente.

Puis à la fermeture du UserForm, la procédure appelante reprend la main.

Et enfin après l'instruction End With, l'objet représentant le UserForm est détruit (équivalent de Set loForm = Nothing).

Mais attention : lorsqu'on ferme le UserForm (par le menu système de la fenêtre ou par l'instruction Unload), celui-ci n'est alors plus totalement accessible.
Si après l'instruction Show, vous essayez de lire par exemple le titre de la fenêtre, vous obtiendrez une erreur :

Par contre la lecture d'un contrôle par exemple fonctionne :

' Rend visible le UserForm
    .Show
    MsgBox .Caption ' KO
    MsgBox .txtInput.Value ' OK
    MsgBox VBA.UserForms.Count ' = 0

La lecture du titre de la fenêtre renvoie une erreur.
La lecture du contenu de la zone de saisie fonctionne.
Le comptage du nombre de UserForm ouverts est 0.

Ceci indique que le UserForm n'est plus chargé (d'ailleurs, on peut vérifier que l'évènement Terminate est exécuté).
Mais ses contrôles sont toujours en mémoire.

Pour éviter cette situation qui risque d'être instable, on va masquer le UserForm au lieu de le fermer.
Lorsqu'on masque le UserForm, celui-ci perd son caractère Modal et la procédure appelante reprend son cours.

Le UserForm masqué est toujours chargé et accessible par code VBA.

Dans l'évènement QueryClose du UserForm, ajoutez le code nécessaire :

' Sur demande de fermeture
Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
    Me.Hide ' Masque le UserForm
    Cancel = True ' Annule la fermeture
End Sub

Puis on gère les clics sur les boutons (évènement Click de chaque bouton).

Pour pouvoir ensuite déterminer si on a cliqué sur le bouton Valider ou non, on ajoute dans le code duUserForm une variable gDiagOK.
Cette valeur sera à Faux par défaut ; on la mettra à Vrai sur clic sur le bouton de validation.
Cette variable sera publique, mais sa durée de vie est de niveau module.
C'est-à-dire qu'elle est initialisée automatiquement à chaque ouverture du UserForm.
On n'a donc pas à la mettre explicitement à Faux.

La déclaration de variable suivante est à écrire en début du code du UserForm :

Public DiagOK As Boolean ' Flag pour validation

Pour le bouton « Valider » (btnOK) :

• on met à jour la variable gDiagOK, ce qui indiquera à la procédure appelante qu'on a validé la saisie ;
• on masque le UserForm.

Pour le bouton « Annuler » (btnCancel) :

• on masque le UserForm.

Masquer le UserForm permet de mettre fin à la boucle d'attente DiagWait tout en conservant le UserForm accessible par VBA.

' Sur clic sur Valider
Private Sub btnOK_Click()
DiagOK = True ' Flag OK
Me.Hide ' Masque le UserForm
End Sub
            
' Sur clic sur Annuler
Private Sub btnCancel_Click()
Me.Hide ' Masque le UserForm
End Sub

Il est enfin facile de récupérer dans la procédure appelante toutes les valeurs souhaitées.

Function TestDialog2()
' Création du UserForm
With New frmDiagInput2
    ' Titre de la fenêtre
    .Caption = "Ma saisie personnalisée"
    ' Message dans l'étiquette
    .lblMessage.Caption = "Veuillez saisir une valeur..."
    ' Valeur par défaut dans la zone de texte
    .txtInput.Value = "Valeur par défaut"
    ' Rend visible le UserForm
    .Show
    ' Test de la saisie
    If .DiagOK Then
        ' si DiagOK = True => on a validé
        MsgBox "Valeur saisie : " & .txtInput.Value
    Else
        ' si DiagOK = False =>  la saisie a été annulée
        MsgBox "Saisie annulée"
    End If
End With
End Function

Notre boîte de dialogue est maintenant terminée !

Voici le code complet du UserForm :

Option Explicit
            
Public DiagOK As Boolean ' Flag pour validation
            
' Sur clic sur Valider
Private Sub btnOK_Click()
DiagOK = True ' Flag OK
Me.Hide ' Masque le UserForm
End Sub
            
' Sur clic sur Annuler
Private Sub btnCancel_Click()
Me.Hide ' Masque le UserForm
End Sub
            
' Sur demande de fermeture
Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
    Me.Hide ' Masque le UserForm
    Cancel = True ' Annule la fermeture
End Sub

Et celui de la fonction appelante :

Function TestDialog2()
' Création du UserForm
With New frmDiagInput2
    ' Titre de la fenêtre
    .Caption = "Ma saisie personnalisée"
    ' Message dans l'étiquette
    .lblMessage.Caption = "Veuillez saisir une valeur..."
    ' Valeur par défaut dans la zone de texte
    .txtInput.Value = "Valeur par défaut"
    ' Rend visible le UserForm
    .Show
    ' Test de la saisie
    If .DiagOK Then
        ' si DiagOK = True => on a validé
        MsgBox "Valeur saisie : " & .txtInput.Value
    Else
        ' si DiagOK = False =>  la saisie a été annulée
        MsgBox "Saisie annulée"
    End If
End With
End Function

Un peu perdu ?
Voici le déroulement du code en résumé :

1. Création du UserForm
   Le UserForm est invisible
2. Modification du UserForm
   Modification des textes, des couleurs…
3. Affichage du UserForm
4. Attente de saisie
   À partir de ce point, dès l'affichage du UserForm, on attend que le UserForm soit rendu invisible.
   La procédure appelante est en attente grâce au caractère Modal du UserForm.
5. Saisie par l'utilisateur
   L'utilisateur effectue la saisie dans la zone de texte.
6. Validation par l'utilisateur de la saisie ou annulation
   Si clic sur un des boutons, le UserForm est rendu invisible.
   Si tentative de fermeture du UserForm, celui-ci est rendu invisible et la fermeture est annulée.
7. Récupération des données saisies
   Lorsque le UserForm est rendu invisible, la procédure appelante reprend la main.
   Le UserForm invisible étant toujours ouvert, on peut lire son contenu (contrôles, variables…).
8. Fermeture du UserForm
   Le UserForm est fermé lorsque l'objet frmDiagInput2 est détruit (après le End With).

Cette boîte de dialogue est simple, mais la méthode permet de faire beaucoup plus complexe.
On peut enrichir le UserForm à loisir.

Dans ce chapitre, nous ajoutons une fermeture automatique du UserForm après un délai défini.
On affichera également le temps restant avant la fermeture.

Modifiez pour cela le UserForm frmDiagInput2 du chapitre précédent.

Dans l'évènement Initialize du UserForm, ajoutez un appel à une procédure DiagTimer.

' Initialisation du UserForm
Private Sub UserForm_Initialize()
Application.OnTime DateAdd("s", 5, Now), "'DiagTimer(" & ObjPtr(Me) & ")'"
End Sub

L'instruction OnTime appelle la procédure DiagTimer après 5 secondes.
On utilise DateAdd pour définir l'heure de déclenchement en fonction de l'heure courante.
Pour identifier le UserForm appelant cette procédure, on passe en paramètre la valeur ObjPtr(Me) qui identifie de manière unique le UserForm courant.

La procédure DiagTimer doit être définie dans un module standard (Insertion => Module).

' Procédure de minuterie
#If VBA7 Then
Public Sub DiagTimer(ptrForm As LongPtr)
#Else
Public Sub DiagTimer(ptrForm As Long)
#End If
Dim loForm As Object
' Parcourt les UserForms ouverts
For Each loForm In VBA.UserForms
    ' Si l'identifiant du UserForm parcouru est celui passé en paramètre
    If ObjPtr(loForm) = ptrForm Then
        ' On exécute la procédure UserForm_Timer de ce UserForm
        loForm.UserForm_Timer
        ' Et on sort de la boucle 
        Exit for
    End If
Next
End Sub

Cette procédure parcourt tous les UserForms ouverts pour trouver le UserForm appelant.
L'identifiant du UserForm appelant a été passé en paramètre.

Il est nécessaire de passer par une procédure dans un module standard car OnTime n'accepte pas d'exécuter directement une procédure d'un UserForm.

On appelle, pour le UserForm trouvé, la procédure UserForm_Timer que nous allons écrire dans notre UserForm.

Lorsque la minuterie se déclenche, on va exécuter les mêmes opérations que sur un clic sur le bouton d'annulation.

' Sur minuterie
Public Sub UserForm_Timer()
btnCancel_Click
End Sub

Affichez la fenêtre de dialogue en exécutant la fonction TestDialog2 créée au chapitre précédent.
La fenêtre se referme après 5 secondes.

Cette méthode est très simple mais on préférait pouvoir paramétrer le délai et visualiser le nombre de secondes restantes.

Pour faire cela, on va d'abord définir une variable (au début du code du UserForm) destinée à contenir le nombre de secondes restantes.

Private gMinuterie As Long ' Nombre de secondes avant fermeture

Cette variable va être initialisée avec le nombre de secondes à attendre, puis décrémentée à chaque seconde.

Ajoutez une propriété (en écriture) au UserForm :

' Initialisation de la minuterie
Public Property Let DiagMinuterie(pSec As Long)
End Property

DiagMinuterie est le nom de la propriété.
pSec est la valeur que l'on affecte à cette propriété.
Let signifie que c'est une propriété en écriture.

C'est-à-dire qu'on écrira (par exemple pour déclencher la propriété DiagMinuterie avec la valeur pSec = 5) :

frmDiagInput2.DiagMinuterie = 5

Dans le code de cette propriété, on va initialiser notre variable gMinuterie avec la valeur affectée à pSec.
Puis on exécute la procédure OnTime avec un intervalle de une seconde.

' Initialisation de la minuterie
Public Property Let DiagMinuterie(pSec As Long)
gMinuterie = pSec ' Nombre de secondes à attendre
Application.OnTime DateAdd("s", 1, Now), "'DiagTimer(" & ObjPtr(Me) & ")'"
End Property

L'appel à OnTime ayant été déplacé, retirez celui créé précédemment dans l'événement UserForm_Initialize.

Et on modifie la procédure Sur minuterie du UserForm (Form_Timer).

' Sur minuterie
Private Sub Form_Timer()
 ' Décrémente le délai
gMinuterie = gMinuterie - 1
' Modifie le texte du bouton Annuler
Me.btnCancel.Caption = "Annuler (" & gMinuterie & ")"
If gMinuterie = 0 Then
    ' Exécute la même procédure que sur clic sur Annuler
    btnCancel_Click
Else
' Relance la minuterie
    Application.OnTime DateAdd("s", 1, Now), "'DiagTimer(" & ObjPtr(Me) & ")'"
End If
End Sub

On commence par décrémenter le délai.
Puis on modifie le texte du bouton « Annuler » pour ajouter le temps restant.
Et enfin si ce temps restant est arrivé à zéro, on exécute le code du bouton d'annulation pour annuler la saisie.
Sinon on relance la minuterie pour une seconde.

Pour finir, on initialise le délai souhaité dans la procédure appelante à l'aide la propriété DiagMinuterie.
Le délai est défini juste avant d'afficher le UserForm avec la méthode Show.

' Délai avant fermeture
    .DiagMinuterie = 5

Notre boîte de dialogue est maintenant autorefermable !

Voici le code complet du UserForm :

Option Explicit
            
Public DiagOK As Boolean ' Flag pour validation
Private gMinuterie As Long ' Nombre de secondes avant fermeture
            
' Initialisation de la minuterie
Public Property Let DiagMinuterie(pSec As Long)
gMinuterie = pSec ' Nombre de secondes à attendre
Application.OnTime DateAdd("s", 1, Now), "'DiagTimer(" & ObjPtr(Me) & ")'"
End Property
            
' Sur clic sur Valider
Private Sub btnOK_Click()
DiagOK = True ' Flag OK
Me.Hide ' Masque le UserForm
End Sub
            
' Sur clic sur Annuler
Private Sub btnCancel_Click()
Me.Hide ' Masque le UserForm
End Sub
            
' Sur demande de fermeture
Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
    Me.Hide ' Masque le UserForm
    Cancel = True ' Annule la fermeture
End Sub
            
' Sur minuterie
Public Sub UserForm_Timer()
 ' Décrémente le délai
gMinuterie = gMinuterie - 1
' Modifie le texte du bouton Annuler
Me.btnCancel.Caption = "Annuler (" & gMinuterie & ")"
If gMinuterie = 0 Then
    ' Exécute la même procédure que sur clic sur Annuler
    btnCancel_Click
Else
' Relance la minuterie
    Application.OnTime DateAdd("s", 1, Now), "'DiagTimer(" & ObjPtr(Me) & ")'"
End If
End Sub

Et celui de la fonction appelante ainsi que de la procédure de minuterie :

Function TestDialog2()
' Création du UserForm
With New frmDiagInput2
    ' Titre de la fenêtre
    .Caption = "Ma saisie personnalisée"
    ' Message dans l'étiquette
    .lblMessage.Caption = "Veuillez saisir une valeur..."
    ' Valeur par défaut dans la zone de texte
    .txtInput.Value = "Valeur par défaut"
    ' Délai avant fermeture
    .DiagMinuterie = 5
    ' Rend visible le UserForm
    .Show
    ' Test de la saisie
    If .DiagOK Then
        ' si DiagOK = True => on a validé
        MsgBox "Valeur saisie : " & .txtInput.Value
    Else
        ' si DiagOK = False =>  la saisie a été annulée
        MsgBox "Saisie annulée"
    End If
End With
End Function
            
' Procédure de minuterie
#If VBA7 Then
Public Sub DiagTimer(ptrForm As LongPtr)
#Else
Public Sub DiagTimer(ptrForm As Long)
#End IfDim loForm As Object
' Parcourt les UserForms ouverts
For Each loForm In VBA.UserForms
    ' Si l'identifiant du UserForm parcouru est celui passé en paramètre
    If ObjPtr(loForm) = ptrForm Then
        ' On exécute la procédure UserForm_Timer de ce UserForm
        loForm.UserForm_Timer
        ' Et on sort de la boucle
        Exit For
    End If
Next
End Sub

Si vous utilisez plusieurs fois un même UserForm de saisie, vous ne souhaitez sans doute pas écrire de code complexe à chaque appel de ce UserForm.

Vous pouvez créer une petite fonction réutilisable, un peu comme la fonction InputBox de VBA.

Par exemple pour une fenêtre de saisie avec paramétrage de :

• le texte d'invite (Prompt) ;
• le titre de la fenêtre (Title) ;
• la valeur par défaut (Default) ;
• le caractère à utiliser pour les mots de passe (PasswordChar) ;
• la minuterie avant fermeture (TimeOut).

En reprenant le UserForm frmDiagInput2 du chapitre précédent, voici un exemple de fonction réutilisable :

Function InputBoxMask(Prompt As String, Optional Title As String, Optional Default As String, Optional PasswordChar As String, Optional TimeOut As Long) As String
' Création du UserForm
With New frmDiagInput2
    ' Titre de la fenêtre
    .Caption = Prompt
    ' Message dans l'étiquette
    .lblMessage.Caption = Title
    ' Valeur par défaut dans la zone de texte
    .txtInput.Value = Default
    ' Masque de saisie
    .txtInput.PasswordChar = PasswordChar
    ' Délai avant fermeture
    .DiagMinuterie = TimeOut
    ' Rend visible le UserForm
    .Show
    ' Test de la saisie
    If .DiagOK Then
        ' si DiagOK = True => on a validé
        InputBoxMask = .txtInput.Value
    Else
        ' si DiagOK = False =>  la saisie a été annulée
       InputBoxMask = ""
    End If
End With
End Function

Il suffit ensuite d'appeler cette boîte de saisie comme une InputBox standard.

vMotDePasse = InputBoxMask("Mot de passe :", "Demande d'accès", "","*",10)

On affiche un UserForm de saisie de mot de passe grâce à la propriété PasswordChar qui cache le texte saisi :

Téléchargez le fichier Excel d'exemples.

Il contient les UserForms et codes de cet article.

Vous y trouverez également un exemple de saisie dans une zone de liste :

Et un exemple de saisie de date avec un calendrier :

Merci à tous ceux qui m'ont aidé à améliorer ce tutoriel par leur relecture technique ou orthographique.