Comment faire clignoter une cellule Excel ? La mise en forme dynamique

Dans ce tutoriel, je vais vous montrer comment créer une mise en forme dynamique avancée sur une cellule Excel afin de faire clignoter celle-ci. Pour cela, nous allons voir comment modifier automatiquement la couleur affectée à une cellule de manière répétée, à un intervalle régulier.

Téléchargement

Vous pouvez télécharger le fichier d'exemple de cet article en cliquant sur le lien suivant :

Tutoriel Vidéo

Partie 1 : Comment faire clignoter des cellules Excel ?

Partie 2 : Comment faire clignoter des cellules Excel selon un critère ?

Partie 3 : Comment faire clignoter toutes les cellules d'une ligne selon un critère ?

1. Introduction

Au cours de mes nombreux tutoriels précédents, vous avez été nombreux à me demander s'il était possible de mettre en place une mise en forme conditionnelle capable de faire clignoter une cellule Excel ?

Malheureusement notre tableur préféré ne propose pas une telle fonctionnalité par défaut…

Mais comme vous le savez Excel est extrêmement puissant et il est possible d'ajouter toutes les fonctionnalités que nous pouvons imaginer !

Pour ce tutoriel, nous allons donc découvrir une méthode qui va nous permettre d’arriver à faire clignoter des cellules en fonction d'un critère que nous définirons.

Et pour cela, nous allons évidemment devoir développer une petite macro commande développé en VBA.

Comme d'habitude, nous reviendrons dans le détail sur l'ensemble des lignes de commandes que nous allons mettre en place, mais si vous souhaitez en savoir davantage, vous retrouverez bien entendu sur le blog excelformation.fr et sur ma chaîne YouTube des centaines de tutoriels qui vous permettront d'en apprendre davantage.

2. Création de la macro-commande

Pour commencer, nous allons devoir lancer l’éditeur de code VBE, qui est l’outil qui permet de développer des macros commandes en VBA.

Pour cela, il existe plusieurs possibilités et nous allons aller au plus rapide en utilisant le raccourci clavier [Alt]+[F11].

VBA s’ouvre alors directement sur le projet sur lequel nous étions en train de travailler, c’est-à-dire le classeur Excel.

Nous allons commencer par y insérer un nouveau module en nous rendant dans le menu Insertion et en cliquant sur Module.

VBA ajoute alors une feuille blanche dans laquelle nous allons pouvoir saisir les lignes de commandes.

Pour commencer, nous allons créer une nouvelle.

Macro, que nous allons appeler, faireClignoter, en utilisant le mot clé Sub, suivi de ce nom :

Sub faireClignoter()

Lorsque nous validons, en appuyant sur la touche [Entrée] du clavier, Excel la ligne End Sub qui vient marquer la fin de la macro.

Tout ce que nous avons saisi entre ces deux lignes se lancera à chaque fois que nous appellerons la macro faireClignoter.

3. Faire clignoter des cellules… manuellement

Maintenant que la macro est créée, nous allons pouvoir y développer son fonctionnement.

Mais avant cela, nous allons revenir sur la feuille de calcul afin de pouvoir y créer une plage de cellules nommées qui nous permettra de manipuler facilement un ensemble de cellules en VBA en les appelant simplement à partir de ce nom.

Pour cela, nous sélectionnons plusieurs cellules, que nous choisissons de manière aléatoire, nous verrons dans une seconde partie comment automatiser la sélection de ces cellules :

Et nous saisissons le nom clignotement dans la zone des noms située en haut à gauche de la barre des formules.

De retour dans notre code, nous pourrons maintenant appeler ces cellules, en saisissant le nom de la plage clignotement entre crochets.

Pour commencer, nous allons modifier la couleur de fond et la couleur de police de ces cellules.

Pour cela, nous allons définir par exemple une couleur de fond rouge et une couleur de police blanche, en utilisant les propriétés Interior.ColorIndex et Font.ColorIndex.

Les index correspondants aux couleurs rouge et blanc sont respectivement le 3 et le 2 :

        [clignotement].Interior.ColorIndex = 3
        [clignotement].Font.ColorIndex = 2

Pour tester, nous pouvons appuyer sur la touche [F5] puis revenir sur la feuille de calculs pour constater qu'effectivement les couleurs des cellules ont été modifiés.

Donc maintenant, pour mettre en place le clignotement, nous allons utiliser une instruction If… Then que nous avions découverte dans un tutoriel précédent et qui permet d'effectuer un test.

Nous allons donc regarder si la première cellule de la plage de cellules clignotement (que - pour rappel - nous récupérons en appelant le nom de la plage nommée entre crochets) a une couleur de fond égal à 3.

Lorsque ce sera le cas, alors nous pourrons supprimer la couleur de fond et redéfinir une couleur de police automatique :

    If [clignotement].Cells(1).Interior.ColorIndex =  3 Then
        [clignotement].Interior.ColorIndex = xlNone
        [clignotement].Font.ColorIndex = xlAutomatic
    End If

En revanche, lorsque ce ne sera pas le cas, nous pourrons modifier les couleurs en rouge et blanc comme nous l'avons fait juste avant en utilisant l’instruction Else :

    If [clignotement].Cells(1).Interior.ColorIndex =  3 Then
        [clignotement].Interior.ColorIndex = xlNone
        [clignotement].Font.ColorIndex = xlAutomatic
    Else
        [clignotement].Interior.ColorIndex = 3
        [clignotement].Font.ColorIndex = 2
    End If

Maintenant, à chaque fois que nous lancerons la macro, les couleurs de cellules alternerons entre ces deux palettes de couleurs.

4. Faire clignoter des cellules… automatiquement

Comme vous pouvez le constater, notre macro fonctionne effectivement, mais à condition de relancer la macro manuellement, ce qui n’est évidemment pas une solution aboutie.

Pour automatiser l’opération, nous allons pouvoir utiliser une instruction, Application.OnTime qui permet de lancer une macro commande à un horaire donné.

Ici, nous souhaiterons relancer la macro faireClignoter, au bout d’une seconde :

    Application.OnTime Now +  TimeValue("00:00:01"), "faireClignoter"

Cela a pour effet d’ajouter un enregistrement dans la mémoire d’Excel pour effectuer cette opération le moment venu.

C’est pourquoi, si nous fermons le classeur, mais qu’Excel reste ouvert (par exemple s’il y a d’autres classeurs d’ouverts en même temps), alors ce dernier va rouvrir le classeur dans lequel se trouve la macro pour pouvoir l’exécuter le moment venu.

Voyons maintenant comment corriger ce problème.

En fait, ici, l’objectif sera maintenant de stocker le moment auquel nous souhaitons que la macro soit à nouveau lancée dans une variable.

Seulement étant donné qu’il s’agit d’une variable que nous allons avoir besoin d’utiliser à plusieurs endroits au sein du projet nous allons la définir en tant que variable publique.

Pour cela nous nous rendons au tout début du module de code afin de saisir la ligne suivante :

Public prochainLancement As Double

De cette manière, la portée de cette variable est étendue à l’ensemble du projet, nous pourrons donc l’exploiter comme nous le souhaitons, même en dehors de la macro.

Maintenant, revenons dans la macro faireClignoter.

Puis, juste avant l’instruction Application.OnTIme, nous allons affecter l’heure du prochain lancement de la macro dans la variable prochainLancement que nous venons de créer.

prochainelancement = Now() +  TimeValue("00:00:01")

De cette manière c’est cette variable que nous allons utiliser pour relancer la macro :

    prochaineLancement = Now() +  TimeValue("00:00:01")
    Application.OnTime prochainLancement,  "faireClignoter"

Le fait d’avoir utilisé une variable pour récupérer l’heure exact du lancement de la macro va maintenant nous permet de l’annuler la programmation du prochain lancement en fermant le classeur.

Pour cela nous revenons dans la feuille de code du classeur en double cliquant sur ThisWorkbook, puis nous allons chercher l’événement qui va se lancer automatiquement lorsque nous allons la fermer le classeur, il s’agit de l’événement BeforeClose. Pour l’ajouter, nous faisons comme nous l’avons vu un peu plus tôt : nous commençons par sélectionner WorkBook dans le premier menu déroulant et BeforeClose dans le second menu déroulant.

Une fois que l’événement est ajouté, il suffit de revenir saisir l’instruction Application.OnTime, en effectuant un simple copier-coller depuis la macro faireClignoter :

Private Sub Workbook_BeforeClose(Cancel As  Boolean)
    Application.OnTime prochainLancement,  "faireClignoter"
End Sub

Nous allons maintenant aller un petit peu plus loin dans le renseignement des arguments en donnant au dernier de ces arguments la valeur de False pour permettre d’annuler la planification du relancement de la macro :

Private Sub Workbook_BeforeClose(Cancel As  Boolean)
    Application.OnTime prochainLancement,  "faireClignoter", , False
End Sub

Avant de tester le fonctionnement de la macro faireClignoter, revenons rapidement sur celle-ci afin d'en améliorer le rendu visuel.

Pour cela, nous pouvons en effet insérer une instruction Application.ScreenUpdating qui permet de stopper le rafraîchissement de l'écran.

Nous donnons alors à celle-ci la valeur de False au tout début de la macro, puis nous n’oublions pas de lui redonner la valeur True en fin de la macro, pour que le rafraîchissement puisse se remettre en route par la suite :

Sub faireClignoter()
    Application.ScreenUpdating = False
…
    Application.ScreenUpdating = True
End Sub 

Pour finir, afin d’éviter toutes sortes de problèmes, notamment si nous supprimons par inadvertance la plage de cellules nommée clignotement, nous allons insérer au tout début de la macro une ligne « On Error Resume Next » qui permet, comme nous l'avons déjà vu dans un tutoriel précédent de passer outre toutes les erreurs que le code pourrait rencontrer, afin de continuer le déroulement de la macro :

    On Error Resume Next

5. Faire clignoter toute une ligne de tableau

Maintenant nous allons répondre à la question posée par Rom Lef dans les commentaires de la vidéo qui demande s’il est possible d’utiliser non plus une valeur numérique, mais directement un texte saisi dans la cellule :

Pour cela nous allons revenir sur la feuille de calcul, afin d’insérer une nouvelle colonne dans notre tableau qui sera donc située dans la colonne C, et nous allons y insérer la formule suivante :

=SI([@[Ventes  annuels]]<$B$7;"Urgent";"")

De retour dans notre code VBA, plus précisément dans la macro plageAutomatique, nous allons maintenant contrôler si la valeur de la cellule obtenue avec la variable c est égale au terme « Urgent », que nous saisissons entre guillemets étant donné qu’il s’agit d’une chaîne de caractère :

    For Each c In [b10:b26]
        If c = "Urgent" Then
            …
        End If
    Next

Nous allons également modifier l’adresse de la plage des cellules depuis laquelle est extraite la variable c : il ne s’agit plus des cellules de la colonne B, mais maintenant de cellules contenues dans la colonne C :

    For Each c In [c10:c26]
        …
    Next

Et maintenant nous allons vouloir que ce ne soit pas uniquement la cellule concernée, donc retournées par la variable c, qui clignotent mais celles situées sur toute la ligne du tableau.

Pour cela nous allons créer une nouvelle variable que nous allons appeler cLigne, que nous allons typer en tant que Range afin que celle-ci puisse enregistrer une plage de cellules.

Ensuite, nous allons lui affecter toute la ligne sur laquelle se trouve la cellule c. Pour cela, nous allons utiliser l’instruction Intersect qui permet comme nous l’avons vu dans un tutoriel précédent de récupérer les cellules qui se trouvent à l’intersection de plusieurs plages de cellule.

Celle-ci va nous permettre de récupérer les cellules qui se trouvent à l’intersection de l’ensemble de la plage de cellules du tableau et de nous la ligne de la cellule c.

Nous pouvons pas utiliser directement toutes les cellules de la ligne c avec c.EntireRow, car dans ce cas-là ce serait toute la ligne de la feuille de calcul qui serait sélectionnée :

    Dim c As Range, p As Range, cLigne As  Range
    
    For Each c In [c10:c26]
        Set cLigne = Intersect(c.CurrentRegion,  c.EntireRow)
        …
    Next

Maintenant que nous avons cette nouvelle variable nous allons pouvoir l’utiliser lors de l’affectation à la plage de la cellule, à la place de la variable c :

        If c = "Urgent" Then
            If p Is Nothing Then
                Set p = cLigne
            Else
                Set p = Union(p, cLigne)
            End If
        End If

6. Faire clignoter les cellules durant un laps de temps

Pour finir nous allons découvrir une autre méthode de fonctionnement qui ne va plus consister à faire clignoter de manière infinie les cellules concernées, nous allons plutôt souhaiter ne les faire clignoter que durant un laps de temps donné, par exemple 4 secondes.

Pour cela, de retour dans la macro faireClignoter, nous allons utiliser une boucle For… Next, qui permet comme nous l’avons vu dans un tutoriel précédent de répéter une opération un certain nombre de fois.

Nous commençons par créer une nouvelle variable i, que nous utiliserons pour la boucle :

    Dim i As Integer
    For i = 1 To 4
    …
    Next

Ensuite à l’intérieur de cette boucle nous allons souhaiter réaliser une pause d’une seconde avant de modifier l’apparence des cellules.

Pour cela, nous allons mettre en place une boucle Do While… Loop.

Pour faire fonctionner cette boucle, nous allons encore créer une variable que nous appelons t (pour « temp »), et dans laquelle nous enregistrons l’horodatage qu’une seconde plus tard :

        Dim t As Double
        t = Now() + TimeValue("00:00:01") 

Ensuite, nous insérons dans cette boucle Do While… Loop l’instruction DoEvents qui permet de ne pas bloquer Excel tant que la macro est en fonctionnement :

        DoEvents 

Pour finir, à la suite de cette boucle, nous venons déplacer les lignes permettant de mettre en place le clignotement :

            Dim i As Integer
    For i = 1 To 3
        Dim t As Double
        t = Now() + TimeValue("00:00:01")
    
        Do While Now < t
            DoEvents
        Loop
        
        If [clignotement].Cells(1).Interior.ColorIndex  = 3 Then
            [clignotement].Interior.ColorIndex =  xlNone
            [clignotement].Font.ColorIndex =  xlAutomatic
        Else
            [clignotement].Interior.ColorIndex = 3
            [clignotement].Font.ColorIndex = 2
        End If
    Next

Il ne reste plus qu’à supprimer les lignes inutiles :

    prochaineLancement = Now() +  TimeValue("00:00:01")
    Application.OnTime prochainLancement,  "faireClignoter"

Ainsi que :

    Application.ScreenUpdating = False    
    Application.ScreenUpdating = True

Pour finir, dans le fonctionnement actuel, nous allons devoir lancer automatiquement la macro lors de chaque modification effectuée sur la feuille, étant donné que celle-ci ne se lance plus de manière infinie comme c’était le cas avant.

Pour cela, nous appellons la macro faireClignoter depuis l’évènement Worksheet_Change, après avoir redéfini la plage de cellules clignotement :

Private Sub Worksheet_Change(ByVal Target As  Range)
    plageAutomatique
    faireClignoter
End Sub