Programmation Excel Avec VBA
Programmation Excel Avec VBA
Couvre
Excel 2021
et
Office 365
Programmation
EXCEL avecVBA
Compatible avec toutes les versions d'Excel
3e édition
3e édition
Maîtrisez la programmation VBA et tirez pleinement profit d’Excel. Cet ouvrage détaille les principes de la programmation orientée objet, le
langage VBA et Visual Basic Editor, l’environnement de programmation Excel.
Intégrez pleinement vos programmes Excel dans le ruban office. Apprenez à créer un fichier XML pour vos programmes VBA afin de les
intégrer dans Excel sous la forme d’un nouvel onglet.
EXCELlez. Le dernier chapitre offre l’occasion de réviser l’ensemble des connaissances acquises lors de votre lecture, en développant un
programme complet de génération de feuilles de paie Excel qui édite en parallèle un fichier Word.
Distribuez. Apprenez à créer un programme d’installation avec Inno Setup pour distribuer vos applications Excel de façon professionnelle.
La nouvelle édition de cet ouvrage intègre un nouveau chapitre qui donne les clés de l’exploitation de la base de registre de Windows pour
le programmeur VBA. Vous y créerez un programme de gestion de licence/abonnement qui lit et écrit dans la base de registre.
Compléments web
Tous les exemples des programmes du livre sont en téléchargement sur notre site Internet https://www.editions-eyrolles.com/dl/0100544.
Au sommaire
Découvrir la programmation Excel. Notions fondamentales de la programmation orientée objet (POO) • Premières macros • Déplace-
ment et sélection dans une macro Excel • Découvrir Visual Basic Editor • Programmer en Visual Basic. Développer dans Visual Basic
Editor • Variables et constantes • Contrôler les programmes VBA • Fonctions Excel et VBA • Manipuler des chaînes de caractères •
Écrire et lire dans la base de registre • Déboguer et gérer les erreurs • Intégrer des applications VBA dans l’interface d’Excel • Dévelop-
per des interfaces utilisateur. Créer des interfaces utilisateur • Exploiter les propriétés des contrôles • Maîtriser le comportement
des contrôles • Notions avancées de la programmation Excel. Programmer des événements Excel • Protéger et authentifier des
projets VBA • Exemple complet d’application Excel. Annexes. Mots-clés pour la manipulation de fichiers et de dossiers • Créer un
programme d’installation pour vos applications Excel avec Inno Setup
D.-J. David. – VBA pour Excel 2010, 2013, 2016. N° 14457, 2016, 324 pages.
N. Barbary. – Excel expert. N° 13692, 2 édition, 2014, 444 pages.
e
J.-M. Lagoda, F. Rosard. – Réaliser des graphiques avec Excel. N° 56425, 2016, 128 pages.
Programmation
Excel avec VBA
Compatible avec toutes les versions d'Excel
3e édition
ÉDITIONS EYROLLES
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Compléments VBA et compléments Office . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
VBA, pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Une application hôte et des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Un langage de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Un environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Conventions typographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Codes sources des exemples du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
PREMIÈRE PARTIE
chapitre 2
Premières macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Créer une macro GrasItalique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Afficher l’onglet Développeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Démarrer l’enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Enregistrer les commandes de la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Exécuter la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Structure de la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Améliorer la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Une autre méthode d’enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Structure de la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Écrire la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Exécution de la macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Choisir l’accessibilité des macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Accessibilité globale ou limitée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Classeurs et modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Le classeur de macros personnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Les macros complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Définir le classeur de stockage lors de l’enregistrement d’une macro . . . . . . . . 51
Accéder aux macros d’un classeur spécifique . . . . . . . . . . . . . . . . . . . . . . . . . . 52
chapitre 3
chapitre 4
DEUXIÈME PARTIE
chapitre 6
chapitre 7
chapitre 8
chapitre 9
chapitre 10
chapitre 11
chapitre 12
TROISIÈME PARTIE
chapitre 14
TextAlign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
TripleState . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
WordWrap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Défilement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
ScrollBars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
KeepScrollsVisible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Delay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Max et Min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
SmallChange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
LargeChange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Accelerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
GroupName . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
HelpContextID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
MouseIcon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
MousePointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
TabIndex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
TabStop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Emplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Height et Width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Left et Top . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
StartUpPosition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Picture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
PictureAlignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
PicturePosition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
PictureSizeMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
PictureTiling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Police . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Font . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
chapitre 15
QUATRIÈME PARTIE
Notions avancées de la p
rogrammation Excel . . . . . . . . 417
chapitre 16
chapitre 17
chapitre 18
ANNEXE A
ANNEXE B
Visual Basic pour Applications, VBA, est la solution de programmation intégrée aux applications
de la suite Office. Grâce à VBA, l’utilisateur d’Excel tire pleinement profit du tableur de Microsoft
en en développant les fonctionnalités pour ses besoins spécifiques. Maîtriser VBA, c’est à coup
sûr améliorer sa productivité.
L’intégration dans Excel de Visual Basic pour Applications, un environnement de dévelop-
pement intégré complet et professionnel, remonte à sa version 97. Office 2013, Office 2016 et
Office 2019 intègrent la version 7.1 de Visual Basic, tandis qu’Office 2010 propose la version 7.0
et que XP, 2003 et 2007 fournissent Visual Basic 6.3. Entre ces versions, les différences sont
quasi-inexistantes.
Cet ouvrage traite de la programmation des versions 97 à Excel 365. Sauf exceptions signalées,
les explications et les exemples proposés sont valides pour toutes les versions d’Excel. En effet,
des unes aux autres, il n’y a pas eu de révolution. Le modèle d’objets s’est affiné et les nouvelles
fonctions d’Excel, apparues au cours des différentes versions du logiciel, peuvent également être
manipulées via la programmation VBA. Cependant, le langage, la gestion des programmes,
l’environnement et les outils au service du développeur – bref, tout ce que vous devez savoir pour
programmer Excel et que cet ouvrage se propose de vous apprendre – restent inchangés d’une
version à l’autre.
Donc, sachez que vous pourrez appliquer les connaissances acquises lors de la lecture de ce livre,
aussi bien avec Excel 2003 sous Windows XP qu’avec la version 2016 et un système Windows 10.
Mieux, les programmes développés pour Excel 97 fonctionnent avec toutes les versions ultérieures
du tableur et, dans la très grande majorité des cas, les programmes développés dans Excel 2016
devraient fonctionner avec les versions antérieures.
Dans cet ouvrage, vous découvrirez les différentes méthodes de création de projets VBA pour
Excel, Visual Basic (le langage de programmation proprement dit) et les outils de développement
et de gestion intégrés de Visual Basic pour Applications. Votre initiation à la programmation
VBA se fera au moyen d’exemples de programmes détaillés et commentés.
Définition
Vous rencontrerez le terme projet tout au long de cet ouvrage. C’est ainsi que l’on nomme un ensemble
de programmes développés avec Visual Basic pour Applications.
Programmation Excel avec VBA
2
Figure 1 – Vous pouvez affecter les macros VBA à des commandes sur des onglets personnalisés.
• Modifier et améliorer les commandes d’une application. Les commandes Excel ne sont pas
toujours adaptées à nos besoins ou présentent parfois des limitations gênantes. Un programme
VBA peut modifier, brider ou compléter les commandes d’une application. Vous pouvez ainsi
intégrer dans un tableau le nom de l’utilisateur, le nombre de pages imprimées et l’imprimante
utilisée chaque fois qu’une impression est lancée à partir d’Excel.
• Faire interagir les différentes applications Office. Un programme VBA sait exploiter des don-
nées issues de fichiers générés par d’autres programmes et interagir avec ceux-ci de façon
transparente pour l’utilisateur. Vous pouvez ainsi créer une commande qui envoie automati-
quement le classeur Excel ouvert en fichier joint dans un courriel Outlook à des destinataires
définis ou qui génère un rapport Word à partir de données Excel et l’imprime.
• Créer des interfaces personnalisées. Les programmes VBA peuvent ramener des tâches com-
plexes à la simple information de champs dans des boîtes de dialogue personnalisées pour
l’utilisateur final, simplifiant ainsi considérablement le travail de celui-ci, tout en vous assurant
qu’aucun oubli ou fausse manipulation n’aura lieu.
Visual Basic pour Applications permet le développement de solutions adaptées à vos besoins.
Les outils que vous apprendrez à manier vous permettront de développer des programmes simples,
sans écrire la moindre ligne de code, comme des programmes complets intégrant une interface
utilisateur adaptée.
La fonction d’un programme VBA peut être d’automatiser une tâche répétitive. Cependant, vous
pouvez aussi créer très vite un petit programme VBA pour faire face à une nécessité immédiate ;
par exemple, afin de généraliser un traitement exceptionnel à l’ensemble d’un document.
Programmation Excel avec VBA
4
Figure 2 – Visual Basic pour Applications vous permet de développer des interfaces utilisateur évoluées.
Des programmes
Les projets VBA sont des programmes ou macros écrits dans le langage Visual Basic. Si vous ne
possédez aucune expérience préalable en programmation, ne vous inquiétez pas : cet ouvrage aborde
le développement de projets VBA à travers l’enregistrement de macros. Lorsque vous l’activez,
l’Enregistreur de macro mémorise chacune de vos actions. C’est votre programmeur personnel :
vous utilisez simplement les commandes d’Excel et il se charge de traduire les actions exécutées
en instructions Visual Basic. Il vous suffit ensuite d’exécuter la macro pour répéter l’ensemble des
commandes enregistrées.
Définition
Le terme macro désigne le regroupement d’un ensemble de commandes en une seule. On parle
parfois de macrocommande pour désigner un programme qui se résume à l’exécution d’une
série de commandes, sans égard pour le contexte. Des macros plus évoluées peuvent répéter
des opérations en boucle ou afficher des boîtes de dialogue qui autorisent une interaction avec
l’utilisateur. Ces programmes se comporteront différemment en fonction des informations entrées
ou de l’état du document sur lequel elles s’exécutent.
Le terme projet est plus large. Il désigne l’ensemble des éléments constituant vos programmes
VBA. Il s’agit toujours de macros, mais à celles-ci peuvent s’ajouter des feuilles – qui constituent
une interface utilisateur permettant de récolter des informations de tout type –, des modules de
classe et autres friandises que vous découvrirez tout au long de cet ouvrage.
L’enregistrement de macros constitue sans aucun doute le meilleur moyen de se familiariser
avec la programmation en Visual Basic. Ainsi, sans connaître le langage – les instructions qui
le composent et la façon dont elles sont structurées –, vous pouvez créer des programmes VBA
et en visualiser ensuite le code.
Introduction
5
Un langage de programmation
Les projets VBA sont développés dans le langage de programmation Visual Basic. Vous décou-
vrirez par la pratique la structure de ce langage et apprendrez rapidement à en discerner les
composants et les relations qu’ils entretiennent. Comme nous l’avons dit précédemment, l’enre-
gistrement de macros constitue une excellente initiation à Visual Basic. C’est sous cet angle que
nous vous ferons découvrir ce langage.
Visual Basic est un langage de programmation orientée objet (POO). Nous présenterons donc
les concepts de ce type de programmation. Vous apprendrez ce qu’on appelle un objet, une pro-
priété, une méthode ou un module de classe. Vous verrez comment conjuguer ces éléments pour
créer des applications Excel souples et puissantes. Visual Basic pour Applications constitue une
bonne approche de la programmation pour le néophyte.
VBA intègre un grand nombre d’instructions, grâce auxquelles vous développerez des macros
qui identifient très précisément l’état de l’application et des documents et reproduisent l’exécution
de la plupart des commandes disponibles dans l’application hôte.
Vous verrez que certaines instructions sont spécifiques à Excel, par exemple celles qui affectent
une formule à une cellule. Vous n’utiliserez probablement qu’un nombre limité de ces instructions,
en fonction de votre usage personnel d’Excel ou des besoins de votre entreprise. Cependant,
certaines apparaîtront presque toujours dans vos macros. C’est par exemple le cas de la propriété
Range, qui renvoie un objet Excel tel qu’une cellule ou une plage de cellules.
Programmation Excel avec VBA
6
D’autres instructions sont communes à l’ensemble des applications Office, notamment celles qui
règlent le comportement d’une macro : réaliser des opérations en boucle, induire des réactions face
à certains paramètres, afficher des boîtes de dialogue simples (figures 3 et 4) ou développer des
interfaces utilisateur évoluées (figure 1), etc. Ce sont ces instructions qui constituent véritablement
ce qu’il est convenu d’appeler le langage Visual Basic. Vous aurez besoin d’y faire appel dès
que vous voudrez créer un programme interactif, capable de se comporter différemment selon le
contexte. Pour la plupart, ces instructions ne peuvent être générées par enregistrement de macros
et doivent donc être éditées manuellement dans Visual Basic Editor.
Figure 4 – Il existe une version VBA et une version Excel de la fonction InputBox.
Cet ouvrage ne se veut pas un dictionnaire du langage, mais un guide qui vous enseignera le
développement de projets VBA de qualité. Vous apprendrez à enregistrer, modifier, exécuter et
déboguer des macros, à créer des interfaces utilisateur ainsi qu’à gérer vos projets VBA. Vous
découvrirez, à travers les exemples de cet ouvrage, un certain nombre d’instructions spécifiques
à la hiérarchie d’objets d’Excel, qui vous familiariseront avec la logique de ce langage.
Définition
La hiérarchie d’objets d’une application, encore appelée modèle d’objets, est le rapport qu’entre-
tiennent entre eux les différents objets d’une application. Ce concept ainsi que les notions spé-
cifiques aux langages orientés objet seront développés au chapitre 1, « Notions fondamentales
de la programmation orientée objet ».
Ce livre présente et illustre d’exemples commentés l’ensemble des structures de contrôle qui servent
à créer très simplement des macros évoluées. Nous vous fournirons les bases du langage Visual
Basic. Elles suffisent pour créer une infinité de macros et répondre à vos besoins spécifiques.
Lorsque les principes du développement de projets VBA vous seront acquis et que vous créerez
vos propres macros, il vous arrivera sûrement d’avoir besoin d’instructions que vous n’aurez pas
rencontrées lors de la lecture de cet ouvrage ; vous pourrez alors utiliser l’Enregistreur de macro
Introduction
7
ou encore les rechercher dans l’aide de Visual Basic pour Applications ou dans l’Explorateur
d’objets – étudié au chapitre 4. Vous verrez que l’aide de VBA fournit une référence complète du
langage, facilement accessible et consultable.
Si vous n’avez aucune expérience de programmation, peut-être ce Visual Basic vous apparaît-il
comme un langage barbare ou inaccessible. Ne vous inquiétez pas : le développement de projets
VBA ne requiert ni expérience préalable de la programmation, ni connaissance globale du lan-
gage. Contentez-vous, au cours de votre lecture, d’utiliser les fonctions nécessaires aux exercices
et que nous vous détaillerons. Cet ouvrage propose un apprentissage progressif et concret : vous
développerez vos premiers projets VBA dès les premiers chapitres.
Un environnement de travail
VBA dispose d’un environnement de développement à part entière : Visual Basic Editor.
Visual Basic Editor est l’environnement de développement intégré des applications Office.
Il permet de visualiser et de gérer les projets VBA, d’écrire, de modifier et de déboguer les macros
existantes, de visualiser comment les commandes propres à une application Office sont traduites
en langage Visual Basic et inversement. C’est un outil de débogage de vos projets VBA d’une
grande efficacité. Il propose nombre d’outils pour tester les macros et en étudier le comportement.
Vous pouvez ainsi exécuter les commandes de la macro pas à pas, en suivre le déroulement, insérer
des commentaires dans le texte de la macro, etc. Enfin, cet environnement intègre des outils très
intuitifs, dédiés au développement d’interfaces graphiques.
Programmation Excel avec VBA
8
Figure 5 – Visual Basic Editor est l’environnement de développement de Visual Basic pour Applications.
Vous apprendrez dans cet ouvrage à utiliser les nombreux outils de Visual Basic Editor à toutes
les phases de développement d’un projet VBA.
Conventions typographiques
Afin de faciliter la lecture, nous avons adopté dans cet ouvrage un certain nombre de conventions
typographiques. Lorsqu’un mot apparaît pour la première fois, il est composé en italique. Les
programmes et les mots-clés du langage Visual Basic apparaissent dans une police à chasse fixe.
Lorsque, dans un programme, un mot signale une information attendue dans le code, celui-ci
apparaît en italique.
Lorsqu’une ligne de code ne peut être inscrite sur une seule ligne de l’ouvrage, cette flèche ( ➥)
en début de ligne indique que le texte est la suite de la ligne précédente.
Par ailleurs, vous rencontrerez au long de cet ouvrage différents types de notes, matérialisées
par des encadrés.
Info
Ces rubriques apportent un complément d’information en rapport avec le sujet traité. Leur lec-
ture n’est pas indispensable, mais elles vous aideront à mieux cerner le sujet.
Introduction
9
Définition
Vous trouverez sous ces rubriques la définition de termes techniques spécifiques à la
programmation VBA.
Attention
Ces rubriques vous mettent en garde contre les risques inhérents à telle ou telle commande ou
manipulation.
Rappel
Il est parfois nécessaire de se rafraîchir la mémoire. Lorsqu’un sujet fait appel à des connais-
sances acquises plusieurs chapitres auparavant, cette rubrique vous les remémore brièvement.
Astuce
Sous cette rubrique, vous trouverez des trucs pour aller plus vite et travailler plus efficacement.
Conseil
Nous vous faisons ici part de notre expérience, en vous prodiguant des conseils qui vous aide-
ront à développer des projets VBA de qualité.
Découvrir la
programmation
Excel
1
Notions fondamentales
de la programmation
orientée objet (POO)
Visual Basic est un langage de programmation orienté objet. En tant que tel, il repose sur des
concepts communs à tous les langages de POO. Avant de vous lancer dans la programmation pour
Excel, il est important de vous familiariser avec ces concepts et le vocabulaire qui les décrit. Plus
concrètement, ce chapitre vous fera découvrir les différents composants de Visual Basic en tant
que langage orienté objet et comment ils s’articulent pour créer des programmes VBA puissants.
Vous ne trouverez pas dans ce chapitre de programmes VBA. Il est destiné à vous donner les
bases et la terminologie sur lesquelles nous nous appuierons tout au long de cet ouvrage. Alors,
patience ! Les connaissances qu’il vous apportera permettront d’appréhender vos premiers pro-
grammes dès le chapitre 2.
Les ouvrages présentant la POO le font presque toujours par analogie avec les objets de la vie
réelle. Nous ne dérogerons pas à cette règle. La programmation orientée objet repose en effet sur
une structure qui rappelle, par de nombreux points, les objets de la vie courante et les rapports
qu’ils entretiennent. Cette analogie rend simples et faciles d’accès des concepts qui, abordés de
façon abstraite, vous apparaîtraient probablement obscurs.
Info
Une collection porte le nom pluriel des objets qu’elle rassemble.
Ainsi, la collection WorkBooks renvoie tous les objets Workbook, soit tous les classeurs ouverts,
la collection Sheets, toutes les feuilles d’un objet WorkBook, la propriété Worksheets, toutes les
feuilles de calcul d’un objet Workbook, etc. La section « Le modèle d’objets d’Excel » située en fin
de chapitre vous fera découvrir les objets Excel les plus importants.
Définition
Le terme Classe désigne la définition commune d’un ensemble d’objets (qu’est-ce qu’une voiture ?), tan-
dis qu’une Collection désigne l’ensemble des objets appartenant à une classe (toutes les voitures en
circulation).
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
15
Lorsque vous parlez d’acheter la Peugeot 504 verte de vos rêves, vous évoquez une voiture
concrète, bien spécifique. Vous créez une instance – on parle aussi d’une occurrence – de
l’objet Voiture. Elle possède toutes les propriétés de la classe Voitures, mais ces propriétés sont
attachées à des valeurs précises. La carrosserie est verte, la vitesse maximale est de x km/h, etc.
Vous pouvez maîtriser le comportement de votre voiture à l’aide des méthodes définies dans la
classe Voitures (Accélérer, Freiner), mais l’effet précis de ces méthodes est étroitement lié aux
propriétés de votre véhicule. La puissance du moteur ne permet pas d’atteindre 200 km/h (mais
vous pouvez décapoter !) ; les freins ne sont pas équipés du système ABS, il faut donc telle dis-
tance pour freiner, etc.
Un programme VBA peut ainsi créer une feuille de calcul Excel en appliquant la méthode Add
(ajouter) à la collection WorkBooks et déterminer les propriétés de ce classeur (son nom, ses options
de protection, le nombre des feuilles qui le composent, etc.)
Info
Lorsque vous créez une instance, cet objet possède toutes les propriétés et méthodes définies dans la
classe. Ce principe essentiel de la programmation orientée objet est appelé instanciation.
Le grand intérêt de la programmation orientée objet, c’est qu’il n’est pas indispensable de savoir
comment fonctionne un objet pour l’utiliser. Lorsque vous achetez une voiture, vous n’avez pas
besoin de savoir comment la carrosserie et le moteur ont été fabriqués, ni comment les différents
composants sont assemblés ; vous vous contentez de choisir un modèle, une couleur, etc. Il vous
suffit de connaître les méthodes propres à la classe Voitures pour l’utiliser. Avec VBA, lorsque
vous créez une instance d’un objet, vous en définissez les propriétés sans vous préoccuper de la
façon dont celles-ci seront appliquées. Il en va de même pour les méthodes que vous utilisez pour
maîtriser le comportement d’un objet. Lorsque vous tournez la clé de contact, le moteur de la
voiture démarre, sans que vous ayez à vous soucier du détail des événements et des technologies
mises en œuvre.
VBA permet, par exemple, de créer des interfaces graphiques pour vos programmes, en déposant
simplement les objets dont vous avez besoin (cases à cocher, zones de texte, boutons de com-
mandes), sur une feuille. Ces objets ont des comportements spécifiques que votre programme
exploitera, sans que vous ayez besoin de vous soucier de leur mécanisme interne.
toilette, dentifrice, brosse à dents, etc. Vous utilisez le savon avec le gant de toilette, le dentifrice
avec la brosse à dents, et vous pouvez faire une toilette complète.
Si vous souhaitez manger, c’est dans la cuisine que vous vous orienterez. Vous y trouverez quelques
objets disponibles dans la salle de bains (savon, robinet, placard). Vous ne devriez cependant
pas y trouver de brosse à dents, ni aucun des objets spécifiques à la toilette. En revanche, vous
pourrez utiliser le four, ouvrir le réfrigérateur et utiliser tous les objets spécifiques de la cuisine.
Les applications du Pack Office sont comparables aux pièces de votre maison. Lorsque vous choi-
sissez de développer un projet VBA, vous choisissez une application hôte. Il s’agit de l’application
Office qui contient les objets sur lesquels vous souhaitez agir. C’est dans cette dernière que vous
développerez vos programmes, et c’est uniquement à partir de cette application qu’ils pourront
être exécutés. Si vous souhaitez travailler sur des textes, vous choisirez d’entrer dans Word. Pour
faire des calculs, vous savez que c’est dans Excel que vous trouverez les objets dont vous avez
besoin. Access sert au développement et au maniement des bases de données, et PowerPoint à la
création de présentations.
Cependant, à l’image des pièces de votre maison, les applications Office ne sont pas hermétiques.
Vous pouvez parfaitement vous préparer un plateau repas dans la cuisine et choisir de manger au
lit. De façon semblable, des projets VBA évolués sont capables d’utiliser des objets de différentes
applications Office. Un programme développé dans Excel peut utiliser des données stockées dans
une base de données Access ou des objets Word pour imprimer un courrier qui accompagnera
une facture, et envoyer un message Outlook de confirmation.
Vous devez choisir une application hôte pour votre projet. Deux critères doivent la déterminer :
• Votre programme sera plus performant et plus simple à développer si l’application hôte est
celle dans laquelle s’exécute l’essentiel des instructions du programme.
• La présence du programme dans l’application hôte doit être logique, et l’utilisateur final doit
y accéder facilement puisque le programme ne pourra être exécuté qu’à partir de celle-ci.
Info
Tous les projets développés dans cet ouvrage seront hébergés dans Excel. Pour accéder aux objets d’une
application autre que l’hôte, vous utiliserez la technologie Automation. L’accès aux objets d’une autre appli-
cation est traité au chapitre 6.
L’application est donc la pièce dans laquelle votre programme s’exécutera. Elle est composée
d’un certain nombre d’objets – constituant une bibliothèque – dont les rapports sont précisément
définis. Les objets d’une application et les rapports qu’ils entretiennent sont représentés sous la
forme d’un organigramme. Tout en haut de l’organigramme se trouve l’application (la pièce dans
laquelle sont rangés tous les objets). Viennent ensuite les classes d’objets de premier niveau de
l’application, auxquelles sont liés d’autres objets ou classes, et ainsi de suite. On appelle cette
structure le modèle d’objets ou la hiérarchie de classes de l’application. La figure 1-1 représente
ce qui pourrait être un modèle d’objets sommaire de l’application Salle de bains.
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
17
Info
Pour la plupart, les éléments d’Excel peuvent être manipulés dans Visual Basic pour Applications en tant
qu’objets. Un classeur, une feuille de ce classeur, une cellule ou une boîte de dialogue Rechercher sont
autant d’objets manipulables dans un programme Visual Basic.
Figure 1-1 – L’ensemble des objets d’une application est structuré selon un modèle d’objets
qui en définit les rapports et la hiérarchie.
Au sommet du modèle se trouve la pièce – l’application. Tous les objets auxquels vous pouvez
accéder y sont contenus. Si l’on établit un modèle d’objets pour l’ensemble des pièces de la maison,
on retrouvera toujours l’objet Pièce au sommet du modèle. De la même façon, au sommet des
modèles d’objets des applications Office, se trouve l’objet Application.
Viennent ensuite les classes situées immédiatement sous l’objet Pièce. Plus on progresse dans le
modèle, plus les objets sont précis et donc spécifiques de la pièce ou de l’application. Dans Excel
par exemple, sous l’objet Application se trouve la collection (ou classe) Workbooks qui englobe tous
les objets Workbook, c’est-à-dire tous les classeurs Excel ouverts. Sous l’objet Workbook se trouve
la classe Worksheets, qui englobe tous les objets Worksheet (toutes les feuilles de calcul) de l’objet
Workbook désigné.
Astuce
Pour accéder à l’aide en ligne des objets Excel, affichez l’Aide de VBA à partir du menu » ? », puis sélec-
tionnez la commande Référence VBA d’Excel. Vous apprendrez à accéder à Visual Basic Editor au pro-
chain chapitre.
Découvrir la programmation Excel
18 Première partie
Notez que l’appartenance des objets à des branches distinctes du modèle ne signifie pas qu’ils
ne peuvent pas interagir. L’objet Savon de Marseille peut se trouver sur l’étagère et vous pouvez
utiliser la méthode Déplacer pour le mettre dans l’objet Baignoire, comme dans l’objet Lavabo.
Un objet peut en englober d’autres ; il est alors qualifié de conteneur. C’est le cas de l’objet
Application, mais c’est aussi vrai pour beaucoup d’autres objets du modèle d’Excel. Par exemple,
un Workbook (classeur) contient des Worksheet (feuilles de calcul), contenant eux-mêmes des Range
(cellules et plages de cellules).
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
19
On accède à l’objet Workbook MonClasseur de la collection Workbooks (tous les classeurs ouverts),
puis à la feuille nommée MaFeuille de la collection Sheets (toutes les feuilles de l’objet
MonClasseur). Une fois le chemin d’accès à l’objet indiqué, on lui applique la méthode Activate.
Info
Outre son nom, chaque objet est identifié par une valeur d’indice représentant sa position dans la collec-
tion. Cette valeur peut être utilisée pour renvoyer un objet précis selon la syntaxe suivante :
Nom_Collection(IndexObjet)
où IndexObjet représente la position de l’objet dans la collection. L’instruction suivante :
Workbooks(2).Activate
active le classeur Excel apparaissant en deuxième position dans la liste des fenêtres du bouton Changer
de fenêtre de l’onglet Affichage.
Découvrir la programmation Excel
20 Première partie
Poursuivons l’analogie. Si vous vous trouvez déjà dans la salle de bains au moment où vous
décidez de vous laver les dents, vous n’avez pas besoin d’y accéder. Si vous regardez déjà parmi
les produits de toilette, il est inutile d’y faire référence.
De façon semblable, dans le code VBA, les objets de niveau hiérarchique supérieur à celui de
l’objet que vous souhaitez atteindre peuvent parfois être ignorés. C’est toujours le cas pour l’objet
Application. En effet, votre projet VBA étant stocké et donc exécuté à partir d’une application
hôte, il est inutile de rappeler que vous êtes dans cette application.
L’expression :
Workbooks("MonClasseur.xlsm").Sheets("MaFeuille").Activate
Info
Une petite finesse sémantique : les objets à proprement parler n’apparaissent jamais dans le code. Pour
faire référence à un objet, on utilise une propriété qui appelle ou renvoie l’objet voulu. Dans les exemples
précédents, Workbooks est une propriété de l’objet Application, qui renvoie tous les classeurs ouverts (la
classe Workbooks).Sheets est une propriété de l’objet Workbook, qui renvoie toutes les feuilles de classeur
(la classe Sheets) de cet objet.
Les propriétés
Revenons à l’analogie avec l’automobile et prenons la classe Voitures. Toutes les propriétés des
objets Voitures y sont définies. Les objets ou classes situés immédiatement sous Voitures dans
le modèle appartiennent à la collection d’objets Voitures. En tant que tels, ils héritent de toutes
les propriétés définies dans la classe Voitures.
Les propriétés peuvent être un attribut de l’objet ou un aspect de son comportement. Par exemple,
les propriétés d’une voiture sont, notamment, sa marque, son modèle, l’état des pneus, l’activation
ou non du moteur, etc. Les propriétés d’un document Word sont son modèle, son nom, sa taille, etc.
Les propriétés prennent des valeurs spécifiques qui distinguent les différents objets de la col-
lection. La propriété Couleur d’un objet Voiture peut prendre la valeur Vert, tandis que la même
propriété d’un objet de la collection est attachée à la valeur Bleu.
Lorsque vous développerez des programmes VBA, vous exploiterez les propriétés d’un objet de
deux façons :
• En modifiant les valeurs attachées aux propriétés de l’objet. Les propriétés dont les valeurs
peuvent être changées sont dites en lecture-écriture.
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
21
Certaines propriétés ne sont pas modifiables et sont dites en lecture seule. Vous pouvez, par
exemple, modifier la propriété Etat_du_moteur (allumé ou éteint) d’un objet Voiture, mais pas
sa propriété Marque. Il est possible de changer le nombre de feuilles qui composent un classeur,
mais pas sa date de création.
• En interrogeant les valeurs attachées aux propriétés d’un objet. Les valeurs des propriétés
peuvent être lues afin de connaître les spécificités de l’objet et d’orienter le comportement
du programme. Par exemple, en supposant que le litre d’essence est à 1,50 euros, si la valeur
BMW est affectée à la propriété Marque d’un objet Voiture et la valeur 40 (litres) affectée à sa
propriété Contenu_Réservoir, vous ferÒez un plein à 60 euros. Si les valeurs Citroën et 2CV sont
respectivement affectées aux propriétés Marque et Modèle et si la propriété Contenu_Réservoir a
une valeur égale à 20, vous ne ferez qu’un plein à 30 euros.
Chaîne de caractères
Une chaîne de caractères est une suite de caractères contigus – lettres, chiffres, espaces ou signes
de ponctuation. Ces données sont aussi qualifiées de type Chaîne ou String. Une chaîne peut
contenir jusqu’à environ deux milliards de caractères. En Visual Basic, les chaînes sont placées
entre guillemets :
• «Paul» ;
• «1254» ;
• «Je suis une chaîne de caractères composée de 59 caractères».
Les chaînes sont interprétées en tant que caractères, et non en tant que valeur numérique.
Autrement dit, la chaîne «1254» est interprétée comme la combinaison des caractères 1, 2, 5 et 4.
La propriété Modèle d’un objet Voiture est toujours une chaîne de caractères. Celle-ci ne peut être
composée que de chiffres – par exemple «2000» – sans que vous puissiez pour autant diviser
cette valeur par un nombre quelconque.
Valeur numérique
Une valeur numérique est une suite de chiffres. Elle peut être un nombre entier ou décimal,
positif ou négatif :
• 0 ;
• 1 548 972 ;
• – 1 245,4542 ;
• 100E4.
Découvrir la programmation Excel
22 Première partie
Info
Le caractère E dans une variable numérique signifie « exposant » et représente une puissance de 10.
Ainsi, la valeur numérique 100E4 est égale à 100 × 104.
Les valeurs numériques sont interprétées comme des chiffres. Il peut s’agir de valeurs comme
d’expressions conjuguant valeurs numériques et opérateurs arithmétiques (* / – +). Par exemple,
les propriétés Contenu_Réservoir et Consommation d’un objet Voiture sont des valeurs numériques.
Leur combinaison détermine combien de kilomètres peuvent être parcourus avant la panne sèche,
selon l’expression arithmétique suivante :
Kilomètres_Avant_Panne_Sèche = Contenu_Réservoir / Consommation
Info
Notez qu’une expression arithmétique peut être composée de nombres (100 / 25), de variables auxquelles
sont affectées des valeurs numériques (nombre1 + nombre2), ou d’une combinaison des deux (nombre1 - 25).
Les variables sont étudiées au chapitre 6.
Les valeurs numériques pouvant être affectées à une propriété varient selon les propriétés et les
objets. Dans Excel par exemple, la taille d’une police doit être comprise entre 1 et 409. Par consé-
quent, la valeur que peut prendre la propriété Size (taille) d’un objet Font (police) d’Excel doit aussi
être comprise entre ces deux valeurs. Dans le cas de l’objet Voiture, la propriété Contenu_Réservoir
doit toujours être supérieure à 0, la valeur maximale dépendant d’autres spécificités de l’objet.
Valeur booléenne
Certaines propriétés ne peuvent prendre que deux états : elles sont vérifiées ou elles ne le sont pas.
Elles sont attachées à une valeur de type Boolean, ou valeur booléenne, qui vaut True ou False.
La propriété Moteur_Allumé d’un objet Voiture est une valeur booléenne : True si le moteur de
l’objet Voiture est allumé, False dans le cas contraire.
Comme vous le verrez au chapitre 16, un classeur Excel gère une vingtaine de propriétés qui
représentent ses options et son état à un moment donné. Nombre de ces propriétés acceptent une
valeur de type Boolean. C’est par exemple le cas de Saved, qui renvoie True si aucune modification
n’a été apportée au document depuis son dernier enregistrement, ou False dans le cas contraire.
Info
En Visual Basic, la valeur True peut être remplacée par -1 et la valeur False par 0. Cette pratique est
cependant déconseillée, puisqu’elle rend la lecture du code moins aisée.
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
23
Constante
Les constantes sont des valeurs intégrées de VBA qui conservent toujours la même valeur.
Lorsqu’une propriété accepte un nombre déterminé d’états, les valeurs représentant ces derniers
sont souvent des constantes et se présentent sous la forme d’une suite de lettres. Les constantes
sont représentées sous forme de chaînes de caractères, mais correspondent en réalité à des valeurs
numériques.
Les constantes intégrées désignent l’état de propriétés pour un objet spécifique. Chacune des appli-
cations Office possède ses propres constantes (puisqu’elle possède ses propres objets). Cependant,
certaines propriétés étant communes, les constantes associées se retrouvent aussi dans toutes les
applications Office. Une constante intégrée de VBA commence par deux lettres en minuscules
indiquant l’application à laquelle elle appartient. Le tableau suivant reprend les préfixes des
constantes VBA les plus courantes pour Microsoft Office.
vb Visual Basic
wd Word
xl Excel
pp PowerPoint
ac Access
ol Outlook
fm Feuilles Visual Basic
Lorsqu’une propriété accepte des constantes pour valeurs, leur nombre est déterminé et corres-
pond aux différents états que peut prendre la propriété. Par exemple, les clignotants d’une voiture
peuvent accepter quatre états différents : désactivés, activés à droite, activés à gauche, position
Warning (les clignotants droite et gauche activés). La propriété État d’un objet Clignotant pourrait
donc accepter l’une des quatre constantes Clignotant suivantes :
ClignotantAucun
ClignotantDroite
ClignotantGauche
ClignotantWarning
où l’argument Shift est une des constantes XlInsertShiftDirection spécifiant à la méthode Insert
la façon dont la cellule sera insérée. Il peut s’agir de la constante xlShiftToRight (les cellules seront
décalées vers la droite) ou de la constante xlShiftDown (les cellules seront décalées vers le bas).
Découvrir la programmation Excel
24 Première partie
Les constantes sont la représentation textuelle de valeurs numériques. Chacune des constantes
Clignotant correspond à une valeur numérique. La propriété ClignotantWarning correspondrait
par exemple à la valeur numérique 3. Vous pouvez indifféremment utiliser les constantes VBA
ou les valeurs numériques auxquelles elles correspondent. Il est cependant conseillé d’utiliser les
constantes, afin de faciliter la lecture du code.
où Expression est une expression renvoyant un objet – un référentiel d’objet – tel que cela a été
décrit dans la section précédente. Propriété est le nom de la propriété que l’on souhaite modifier
(toujours séparée de l’objet auquel elle se réfère par un point) et valeur est la valeur que vous
souhaitez lui affecter.
Le type de la valeur (chaîne, nombre, constante ou booléen) doit être adapté à la propriété. Si tel
n’est pas le cas, le programme génère une erreur. Par exemple, la propriété Contenu_Réservoir
d’un objet Voiture n’accepte qu’une valeur numérique ; vous ne pouvez pas lui affecter une chaîne
de caractères.
Le tableau 1-1 illustre différentes possibilités de modifier l’objet Voiture MaVoiture.
Pour mémoriser la valeur d’une propriété d’un objet donné, on la stocke généralement dans une
variable, selon la syntaxe suivante :
variable = Expression.Propriété
L’instruction suivante passe la fenêtre active en mode d’affichage Aperçu des sauts de page, en
définissant sa propriété View à xlPageBreakPreview.
ActiveWindow.View = xlPageBreakPreview
L’instruction suivante stocke dans la variable TypeAffichage la valeur représentant le type d’affi-
chage en cours :
TypeAffichage = ActiveWindow.View
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
25
Les méthodes
Les méthodes représentent les actions qu’un objet peut exécuter. Tandis que les propriétés
définissent un état, les méthodes déterminent un comportement et elles dépendent étroitement
de l’objet. Les objets de la classe Voitures disposent de méthodes telles que Tourner, Freiner,
Accélérer, etc.
Cependant, certaines méthodes peuvent être communes à des objets différents, même si elles ont
des conséquences différentes. Par exemple, la méthode Ouvrir peut s’appliquer aux objets Porte,
Coffre ou Cendrier d’une voiture, comme à un objet Porte ou Robinet d’une maison. Certaines
méthodes se retrouvent dans toutes les applications Office. C’est le cas pour toutes les commandes
communes aux applications. Par exemple, Open (ouvrir) et Close (fermer) s’appliquent aussi bien
à un classeur Excel qu’à un document Word, un formulaire Access ou encore une présentation
PowerPoint.
Une méthode peut avoir des conséquences sur l’état de certaines propriétés de l’objet auquel elle
s’applique, voire sur d’autres objets. Par exemple, si vous appliquez la méthode Accélérer à un
objet Voiture, la valeur affectée à la propriété Vitesse de cet objet augmentera.
Si vous modifiez le contenu d’une cellule d’un classeur Excel, la taille de la cellule sera peut-être
modifiée en conséquence. Si d’autres cellules sont liées par des formules à la cellule dont vous
modifiez la valeur, leurs valeurs seront mises à jour en conséquence. Chaque fois que vous créez
un nouveau classeur à l’aide de la méthode Add, la valeur de la propriété Count de la collection
Workbooks (le nombre de classeurs ouverts) est incrémentée de 1. Chaque fois que vous fermez
le classeur à l’aide de la méthode Close, la valeur de la propriété Count de la collection Workbooks
est décrémentée de 1.
En outre, pour exécuter correctement une méthode, il est parfois nécessaire de modifier au pré-
alable les propriétés de l’objet auquel elle s’applique. Par exemple, si vous souhaitez appliquer la
méthode Tourner à un objet Voiture, vous devez auparavant modifier la propriété Etat_Clignotant
de l’objet Clignotant de cette voiture.
La syntaxe pour appliquer une méthode à un objet est la suivante :
Expression.Méthode
où Expression est une expression renvoyant un objet – un référentiel d’objet – et Méthode est le
nom de la méthode que l’on souhaite exécuter (toujours séparée de l’objet auquel elle se réfère
par un point).
Une méthode peut aussi s’appliquer à une collection d’objets :
Collection.Méthode
Vous pouvez, par exemple, arrêter tous les objets de la collection Voitures :
Voitures.Arrêter
Pour fermer tous les classeurs ouverts dans une session Excel, vous utiliserez l’instruction suivante :
Workbooks.Close
Découvrir la programmation Excel
26 Première partie
Cette syntaxe est aussi utilisée pour créer une occurrence d’un objet dans une collection. La
méthode utilisée est alors généralement Add – l’équivalent Visual Basic de l’onglet Fichier. Par
exemple, pour créer un nouveau classeur Excel, vous ferez appel à Workbooks.Add.
Vous définissez ensuite les propriétés de l’objet ainsi créé, comme nous l’avons vu dans la section
« Les propriétés » de ce chapitre.
Les événements
Un événement est une action reconnue par un objet et qui déclenche l’exécution d’un programme
lorsqu’elle survient. On parle alors de procédure événementielle. Un clic de souris ou la frappe
d’une touche sont des exemples d’événements pouvant être interprétés par un programme VBA.
Définition
Une procédure événementielle est une procédure attachée à un événement utilisateur tel qu’un clic de
souris, la frappe d’une touche, l’activation d’une feuille de calcul, etc. La procédure s’exécute lorsque l’évé-
nement auquel elle est attachée est reconnu par l’application.
Les objets de la collection Voitures reconnaîtront par exemple l’événement Choc, dont la détec-
tion entraînera l’ouverture de l’objet Airbag, autrement dit l’application de la méthode Ouvrir à
ce dernier.
Les événements s’utilisent essentiellement avec les contrôles de formulaires que vous développerez
et avec les objets. Vous apprendrez à exploiter les événements utilisateur affectant un formulaire
aux chapitres 13 et 14. Les feuilles de calcul, les graphiques, les classeurs et l’application Excel
gèrent aussi des événements. Vous apprendrez à créer des procédures événementielles pour ces
objets au chapitre 16.
Les fonctions
Les fonctions servent à renvoyer une information selon les éléments qui leur sont fournis. Le type
de l’information renvoyée varie d’une fonction à l’autre. Il peut s’agir d’une chaîne de caractères,
d’une valeur numérique, booléenne, de type Date, etc. Visual Basic intègre un certain nombre de
fonctions exploitables directement. Par exemple, Asc renvoie le code ASCII du caractère sélec-
tionné, tandis que Int renvoie la partie entière d’un nombre. Certaines fonctions sont particuliè-
rement utiles. C’est le cas de MsgBox, qui affiche une boîte de dialogue contenant des boutons (tels
que Oui, Non ou Annuler) et qui renvoie une valeur reflétant le choix de l’utilisateur.
Vous créerez aussi vos propres fonctions pour traiter les valeurs qui leur seront passées et renvoyer
une valeur ensuite utilisée par le programme. Dans le cas d’un objet Voiture, vous pouvez créer
une fonction Coût_Plein qui exploitera les propriétés Contenu_Réservoir et Contenance_Réservoir
de l’objet, ainsi qu’une variable représentant le prix de l’essence, pour renvoyer une valeur cor-
respondant au coût d’un plein. Lorsque vous créez des fonctions VBA pour Excel, celles-ci sont
accessibles pour l’utilisateur final comme n’importe quelle fonction Excel intégrée.
Notions fondamentales de la programmation orientée objet (POO)
Chapitre 1
27
Les fonctions ont généralement besoin de paramètres ou arguments. Si les arguments obliga-
toires d’une fonction ne lui sont pas passés au moment de l’appel, une erreur est générée. Dans
le cas précédent, trois paramètres de type numérique doivent être passés à la fonction Coût_Plein
pour qu’elle s’exécute correctement : le contenu du réservoir, sa contenance et le prix de l’essence.
Définition
Le code est le texte, écrit dans le langage de programmation, constituant le programme. Le codage
désigne le fait de générer du code, soit en utilisant l’Enregistreur de macro, soit en l’écrivant directement
dans la fenêtre de code de Visual Basic Editor.
Figure 2-1 – Activez l’onglet Développeur pour accéder aux fonctions de programmation du logiciel.
Premières macros
Chapitre 2
33
Démarrer l’enregistrement
Avant de commencer l’enregistrement de la macro GrasItalique, sélectionnez une cellule à laquelle
vous attribuerez les formats de caractères voulus.
1. Cliquez sur le bouton Enregistrer une macro du groupe Code de l’onglet Développeur.
2. Par défaut, la zone Nom de la macro indique Macro1. Remplacez ce nom par GrasItalique.
Conseil
Il est plus rapide d’enregistrer une macro sous le nom que lui attribue Excel par défaut. Cependant, si
vous enregistrez plusieurs macros, celles-ci deviendront rapidement indiscernables. Attribuez-leur un nom
représentatif et entrez une rapide description de la fonction de chacune dans la zone Description ; vous
n’aurez ainsi aucun problème pour les distinguer.
Placez le curseur dans la zone de texte Touche de raccourci et saisissez une lettre qui, combinée
à la touche Ctrl, sera affectée à l’exécution de la macro GrasItalique (dans notre exemple, la
combinaison Ctrl+B). Vous pouvez aussi maintenir la touche Maj enfoncée de façon à affecter
à votre macro une combinaison Ctrl+Maj+Lettre.
La boîte de dialogue Enregistrer une macro doit maintenant se présenter comme à la figure 2-4.
Attention
Lorsque vous attribuez un raccourci clavier à une macro, aucune indication ne vous est fournie quant à
l’affectation ou non de ce raccourci à une commande. Si le raccourci choisi était déjà affecté à une com-
mande Excel, il sera réattribué à la macro sans que vous en soyez informé. Veillez donc à ne pas attribuer
à votre macro un raccourci clavier déjà utilisé par Excel, particulièrement si d’autres utilisateurs sont ame-
nés à utiliser vos macros.
Attention
Si vous sélectionnez une cellule après avoir déclenché l’Enregistreur de macro, cette manipulation sera
enregistrée. Par conséquent, la macro appliquera la mise en forme Gras Italique à cette cellule et non aux
cellules actives au moment de son exécution.
Exécuter la macro
Pour exécuter la macro GrasItalique, vous pouvez passer par la boîte de dialogue Macro ou – et
c’est là que réside son intérêt – utiliser le raccourci clavier que nous lui avons attribué.
2. Dans la liste des macros disponibles, sélectionnez GrasItalique, qui s’affiche alors dans la zone
Nom de la macro.
3. Cliquez sur le bouton Exécuter. La boîte de dialogue Macro disparaît automatiquement et les
cellules sélectionnées s’enrichissent des attributs Gras et Italique (voir figure 2-7).
Si la procédure d’exécution que vous venez de mettre en œuvre convient à certaines macros plus
complexes et d’un usage moins fréquent, elle ne présente pas d’intérêt pour GrasItalique puisqu’elle
nécessite plus d’opérations pour l’utilisateur qu’elle n’en exécute.
Le raccourci clavier
Sélectionnez le texte voulu, puis tapez le raccourci clavier attaché à la macro (Ctrl+B).
En un clin d’œil, les cellules sélectionnées se sont enrichies des attributs de caractères voulus.
Structure de la macro
Lors de l’enregistrement de la macro, les actions que vous avez effectuées ont été converties en
langage Visual Basic. Pour en visualiser la syntaxe :
1. Activez l’onglet Développeur, puis cliquez sur le bouton Macros. Dans la boîte de dialogue,
sélectionnez la macro GrasItalique. Elle s’affiche dans la zone Nom de la macro.
2. Cliquez sur le bouton Modifier. Visual Basic Editor, l’environnement de développement intégré
d’Office, s’ouvre sur la fenêtre Code de votre macro (voir figure 2-8).
Info
Lorsque vous tentez de modifier la macro, si Excel affiche le message « Impossible de modifier une macro
dans un classeur masqué… », vous devez afficher le fichier PERSONAL.XLSB. Sélectionnez l’onglet Affi-
chage, puis cliquez sur le bouton Afficher du groupe Fenêtre.
Premières macros
Chapitre 2
37
Figure 2-8 – La fenêtre Code de Visual Basic Editor permet de visualiser et de modifier le code d’une macro.
Ces deux instructions encadrent systématiquement toute macro enregistrée. Sub est l’abréviation
de subroutine qui signifie sous-routine ou sous-programme. Les macros sont en effet des sous-
programmes de l’application hôte. GrasItalique() est le nom de la sous-routine – c’est-à-dire le
nom de la macro. End Sub indique la fin. Ces instructions sont indispensables au fonctionnement de
toute macro. Cependant, vous n’aurez pas à vous en soucier : lorsque vous enregistrez une macro,
les instructions qui la composent sont automatiquement encadrées par celles-ci.
Directement placées derrière l’instruction Sub NomMacro, des lignes de commentaires reprennent
les informations que contenait la zone Description lors de l’enregistrement (voir figure 2-3), en
l’occurrence le nom du créateur, la date d’enregistrement, ainsi que le texte descriptif de la macro.
Info
Les commentaires sont des indications ajoutées dans le code d’un programme afin d’en faciliter la lecture.
Certains éléments du code apparaissent en couleur. Cette mise en valeur distingue aisément les
éléments constitutifs du code. Par défaut, Visual Basic Editor applique le vert aux commentaires
et le bleu aux mots-clés du langage.
Découvrir la programmation Excel
38 Première partie
Définition
Un mot-clé est un mot ou un symbole reconnu comme élément du langage de programmation Visual Basic.
Il peut s’agir d’une structure de contrôle, d’une fonction ou de tout autre élément du langage indépendant
du modèle d’objets de l’application hôte. Les structures de contrôle sont des instructions qui servent à
diriger le comportement d’une macro (par exemple, répéter une opération en boucle, n’effectuer une ins-
truction que dans un contexte spécifique). Vous apprendrez à utiliser les structures de contrôle de Visual
Basic au chapitre 7.
Entre les instructions Sub GrasItalique() et End Sub se trouvent les instructions qu’exécutera la
macro :
With Selection.Font
.Name = "Arial"
.FontStyle = "Gras italique"
.Size = 10
.Strikethrough = False
.Superscript = False
.Subscript = False
.OutlineFont = False
.Shadow = False
.Underline = xlUnderlineStyleNone
.ThemeColor = xlThemeColorLight1
.TintAndShade = 0
.ThemeFont = xlThemeFontMinor
End With
Info
Si vous utilisez une version antérieure à Excel 2007, les trois lignes ThemeColor, TintAndShade et The-
meFont sont remplacées par une seule ligne de code :
.ColorIndex = xlAutomatic
Il s’agit des commandes effectuées lors de l’enregistrement : ces lignes indiquent à la macro les
actions à accomplir. Leur structure peut vous dérouter, mais vous vous y habituerez rapidement :
• L’expression Selection.Font indique à la macro qu’il s’agit d’appliquer un format de police
aux cellules sélectionnées :
– Selection est une propriété qui renvoie un objet Selection représentant la sélection en cours
dans le document actif. Lorsque vous enregistrerez des macros, vous verrez que certains
objets, et les propriétés qui leur sont associées, sont très usités. C’est le cas de Selection,
qui apparaît dans le code d’une macro Excel chaque fois qu’une opération (format de police,
dimensions, définition d’une catégorie de données, etc.) est effectuée sur une plage de cel-
lules sans que celle-ci soit définie auparavant ;
– Font indique à la macro qu’il s’agit d’appliquer un format de police à l’objet Selection
(les cellules sélectionnées).
Premières macros
Chapitre 2
39
• Les instructions With et End With encadrent l’ensemble des propriétés de l’objet Font. Comme
tout mot-clé, elles apparaissent en bleu dans la fenêtre de code. Lorsque, durant l’enregistrement
d’une macro, vous faites appel à une boîte de dialogue dans laquelle plusieurs options sont
définies, cette structure est utilisée pour coder l’ensemble des options de la boîte de dialogue,
selon la syntaxe suivante :
With Objet
Propriétés de l'objet
End With
Définition
Le verbe « coder » désigne la transcription d’actions propres à l’application dans un langage de program-
mation déterminé.
• Chaque ligne située entre les instructions With Selection.Font et End With correspond à une
option de l’onglet Police lors de l’enregistrement de la macro. Il s’agit des propriétés de l’objet
Font. Remarquez que les propriétés sont toujours précédées d’un point.
À chaque propriété est affectée une valeur. Elle indique l’état de cette option lors de l’enre-
gistrement de la commande. Cette valeur peut être :
– False ou True (valeur booléenne). Indiquent respectivement que l’option n’était pas cochée
(faux) ou qu’elle l’était (vrai). Superscript = False indique ici que la case à cocher Exposant
était décochée.
Rappel
Vous pouvez aussi utiliser les valeurs –1 et 0 à la place de True et False. Par exemple, l’expression
.Superscript = True pourra être remplacée par .Superscript = –1.
– Une chaîne de caractères. Lorsqu’une propriété est attachée à une chaîne de caractères, cette
valeur est placée entre guillemets. Name = "Arial" indique le nom de la police en cours dans
la boîte de dialogue Police lors de l’enregistrement de la macro.
– Une valeur numérique. Les valeurs possibles varient d’une propriété à l’autre. Size = 10
indique ici que le corps de la police est de 10 points. Dans Excel, cette valeur doit être
définie entre 1 et 409.
– Une constante. Il s’agit d’une valeur prédéfinie qui permet de paramétrer une propriété. Par
exemple, la propriété Underline définit le type de soulignement appliqué à la police ou à la
plage. Sa valeur correspond à l’état de l’option Soulignement lors de l’enregistrement de la
macro. Elle est ici attachée à la constante xlUnderlineStyleNone, qui correspond à l’option
Aucun de la liste déroulante Soulignement. Il existe une constante XlUnderlineStyle spéci-
fique pour chaque option de cette liste (xlUnderlineStyleDouble pour Soulignement double,
xlUnderlineStyleSingle pour Soulignement simple, etc.).
Découvrir la programmation Excel
40 Première partie
Format de cellule
Propriété Valeurs autorisées
(onglet Police)
Name Zone de texte Police Chaîne de caractères correspondant au nom d’une police disponible
dans la zone de liste modifiable 1.
FontStyle Zone de texte Style Chaîne de caractères correspondant à l’option sélectionnée dans la
zone de liste 1.
Size Zone de texte Taille Valeur numérique représentant le corps de la police. Cette valeur
peut être comprise entre 1 et 409 1.
Strikethrough Case à cocher Barré True (barré) ou False (non barré) 1.
Superscript Case à cocher True (mise en forme exposant) ou False (pas de mise en forme
Exposant exposant) 1.
Les attributs Exposant et Indice ne pouvant être appliqués à une
même sélection, lorsque vous affectez la valeur True à la propriété
SuperScript, la propriété Subscript prend la valeur False2.
Subscript Case à cocher Indice True (mise en forme indice) ou False (pas de mise en forme indice) 2.
Les attributs Indice et Exposant ne pouvant être appliqués à une
même sélection, lorsque vous affectez la valeur True à la propriété
SubScript, la propriété SuperScript prend la valeur False2.
OutlineFont [Aucune True ou False (sans effet).
et Shadow correspondance] Ces propriétés indiquent respectivement si la police possède une
mise en forme Relief et Ombré. Elles ne correspondent à aucune
option de la boîte de dialogue Format de cellule, mais ont été
conservées comme propriétés de l’objet Font d’Excel. Elles sont
sans effet sur la police.
Underline Liste déroulante Une des cinq constantes xlUnderlineStyleNone représentant les
Soulignement cinq types de soulignement disponibles dans Excel 1.
ThemeColor, Onglet Remplissage Respectivement une des constantes xlThemeColor (la couleur de
TintAndShade motif), une valeur numérique comprise entre –1 et 1 représentant la
et ThemeFont teinte appliquée à cette couleur (de sombre à lumineux) et une des
constantes xlThemeFont qui correspond à la police du thème.
1. Si vous demandez la valeur d’une propriété pour une plage contenant des cellules dont les attributs correspondants
sont différents, la valeur Null sera renvoyée. Par exemple, si vous cherchez la valeur de la propriété Name de l’objet
Font d’une plage de cellules contenant à la fois des cellules en police Arial et d’autres en police Times, la valeur Null
sera renvoyée.
2. Notez que cet état est le reflet de ce qui se passe dans la boîte de dialogue Police. En effet, vous ne pouvez pas
cocher à la fois l’option Indice et l’option Exposant.
Comme le montre le tableau précédent, les actions exécutées sont codées selon des principes
récurrents auxquels l’enregistrement de macros vous familiarisera.
Premières macros
Chapitre 2
41
La macro GrasItalique ouvre donc (virtuellement) la boîte de dialogue Format de cellule sur
l’onglet Police et y définit les options telles qu’elles l’ont été lors de l’enregistrement. Elle applique
ensuite ces propriétés au texte sélectionné.
Fermez la fenêtre Visual Basic Editor, en sélectionnant la commande Fermer et retourner à
Microsoft Excel du menu Fichier.
Améliorer la macro
Sélectionnez maintenant une cellule dont la police et le corps sont différents de ceux de la plage
sélectionnée lors de l’enregistrement de la macro. Tapez le raccourci clavier affecté à la macro
(Ctrl+B). Celle-ci s’exécute.
À la figure 2-9, on constate que les attributs Gras et Italique ont bien été appliqués, mais la police
et le corps du texte ont changé. Tous les arguments en cours dans la boîte de dialogue Police ont
en effet été pris en compte lors de l’enregistrement de la macro.
Cela apparaît clairement dans la fenêtre de code (voir figure 2-7) : les arguments .Size = 10 et
.Name = "Arial" correspondent à la police et au corps du texte sélectionnés lors de l’enregistre-
ment de la macro.
Figure 2-9 – L’ensemble des arguments en cours lors de l’enregistrement de la macro est appliqué.
Info
La structure With…End With est utilisée pour paramétrer les propriétés d’un objet sans avoir à répéter la
référence à cet objet pour chaque propriété. Puisque la macro ne définit ici qu’une propriété, il est inutile
d’utiliser cette structure. La macro se présente alors ainsi :
Sub GrasItalique()
Selection.Font.FontStyle = "Gras italique"
End Sub
Au fur et à mesure que vous avancerez dans l’apprentissage de la programmation Excel, vous
découvrirez par la pratique les différents éléments des boîtes de dialogue Macro et Enregistrer
une macro. Le tableau 2-2 en présente rapidement les fonctions.
Bouton Description
Boîte de dialogue Macro
Exécuter Exécute la macro sélectionnée – dont le nom apparaît dans la zone de texte Nom de la
macro.
Annuler Ferme la boîte de dialogue Macro.
Pas à pas détaillé Ouvre la fenêtre de code de la macro sélectionnée dans Visual Basic Editor et l’exécute
étape par étape (instruction par instruction). Cette commande constitue un précieux outil de
débogage.
Modifier Ouvre la fenêtre de code de la macro sélectionnée dans Visual Basic Editor afin d’en
permettre la modification.
Créer Ouvre, dans Visual Basic Editor, une fenêtre Code simplement composée des instructions
Sub NomMacro() et End Sub. Pour accéder à ce bouton, il faut auparavant saisir un nom de
macro dans la zone Nom de la macro. Ce nom ne peut être le même que celui d’une macro
existante.
Supprimer Supprime la macro sélectionnée. Un message de confirmation s’affiche.
Options Ouvre la boîte de dialogue Options de macro pour la macro sélectionnée, permettant de lui
attribuer un raccourci clavier et d’en modifier la description.
Nom de la macro Permet de désigner une macro existante ou de saisir le nom d’une nouvelle macro. Lorsque
vous en sélectionnez une, son nom s’affiche dans cette zone de texte.
Macros dans Désigne le classeur dont vous souhaitez afficher les macros 1.
Premières macros
Chapitre 2
43
Bouton Description
Boîte de dialogue Enregistrer une macro
Nom de la macro Nom de la macro qui sera enregistrée. Si le nom spécifié est déjà attribué à une macro
existante, l’application hôte affichera une boîte de dialogue vous demandant de confirmer le
remplacement de l’ancienne.
Touche de raccourci Affecte un raccourci clavier à la macro que l’on souhaite enregistrer.
Enregistrer Désigne le classeur où sera stockée la macro 1. Le lieu de stockage détermine à partir de
la macro dans quels documents la macro sera disponible, c’est-à-dire où elle pourra être exécutée, modifiée
ou supprimée.
Description Destinée à la saisie d’une description de la macro. Par défaut, la date de création et le
créateur apparaissent dans cette zone.
Bouton OK Démarre l’enregistrement de la macro sans qu’aucun raccourci ne lui soit attribué.
Bouton Annuler Ferme la boîte de dialogue sans déclencher l’Enregistreur de macro.
1. Le stockage et la disponibilité des macros sont traités à la fin de ce chapitre.
Enregistrement
Pour réenregistrer la macro GrasItalique :
1. Sélectionnez une cellule.
2. Cliquez sur le bouton Enregistrer une macro de l’onglet Développeur. Dans la zone Nom de
la macro de la boîte de dialogue, saisissez GrasItalique.
3. Affectez un raccourci clavier à la macro et saisissez une brève description.
4. Cliquez sur le bouton OK. Une boîte de dialogue s’affiche, vous demandant de confirmer le
remplacement de la macro existante. Confirmez.
5. Cliquez tour à tour sur les icônes Gras et Italique de la barre d’outils.
Découvrir la programmation Excel
44 Première partie
Structure de la macro
Observons la façon dont ces actions ont été codées en Visual Basic. Ouvrez la fenêtre de code de
GrasItalique (bouton Macro de l’onglet Développeur, puis Modifier).
Le texte de la macro se présente ainsi :
Sub GrasItalique()
Selection.Font.Bold = True
Selection.Font.Italic = True
End Sub
Les propriétés Bold et Italic de l’objet Font sont définies à True, indiquant que les cellules sélec-
tionnées seront enrichies des attributs gras et italique.
Remarquez l’absence de la structure With…End With. Cette structure n’est utilisée que lorsque
plusieurs propriétés d’un objet sont validées dans une seule action – c’est le cas pour toutes les
options d’une boîte de dialogue au moment où vous cliquez sur le bouton OK.
Vous pouvez cependant utiliser cette structure afin d’améliorer la lisibilité de la macro. Elle doit
alors se présenter ainsi :
Sub GrasItalique()
With Selection.Font
.Bold = True
.Italic = True
End With
End Sub
Écrire la macro
Maintenant que vous connaissez la structure de la fenêtre de code, vous allez écrire directement
la macro, sans l’aide de votre programmeur attitré, l’Enregistreur de macro.
Pour écrire GrasItalique :
1. Cliquez sur le bouton Macros de l’onglet Développeur. Sélectionnez GrasItalique. Cliquez sur
le bouton Supprimer. Confirmez la suppression.
2. Cliquez de nouveau sur le bouton Macros de l’onglet Développeur. Dans la zone Nom de la
macro, saisissez GrasItalique, puis cliquez sur le bouton Créer. Visual Basic Editor s’ouvre
sur la fenêtre de code.
Premières macros
Chapitre 2
45
3. Insérez une ligne entre Sub GrasItalique() et End Sub. Saisissez simplement le texte de la macro
tel que nous l’avons vu lors de la section précédente.
4. Dans le menu Fichier, choisissez Enregistrer PERSONAL.XLSB, puis Fermer et retourner
dans Microsoft Excel.
Créer une macro n’est pas plus compliqué que cela.
Contrairement à la méthode de l’enregistrement, la création d’une macro ne permet pas l’attri-
bution d’un raccourci clavier. Pour y remédier, procédez comme suit :
1. Choisissez Outils > Macro > Macros ou, si vous utilisez Excel 2007, cliquez sur le bouton
Macros de l’onglet Développeur.
2. Sélectionnez GrasItalique, puis cliquez sur le bouton Options.
3. Dans la boîte de dialogue qui s’affiche, indiquez un raccourci clavier et saisissez éventuellement
une description pour la macro (voir figure 2-11). Validez en cliquant sur OK.
Info
Visual Basic pour Applications n’impose pas la saisie des majuscules. Celles-ci sont placées dans le code
dans le seul but d’en faciliter la lecture. Vous pouvez parfaitement saisir du texte entièrement en minus-
cules (selection.font) dans une fenêtre de code.
Découvrir la programmation Excel
46 Première partie
Astuce
Si vous saisissez du texte en minuscules dans une fenêtre de code, Visual Basic replace les majuscules
dans les instructions qu’il reconnaît lorsque vous changez de ligne. S’il ne modifie pas la casse d’une ins-
truction saisie en minuscules, c’est qu’il ne la reconnaît pas. Par exemple, selection.font.bold = true
deviendra Selection.Font.Bold = True lors du changement de ligne ; en revanche, si vous tapez
selection.font.old = true, Word ne placera pas de capitale à old. C’est un bon moyen de vérifier que
vous n’avez pas commis de fautes lors de la saisie.
Exécution de la macro
Une macro créée s’exécute exactement de la même façon qu’une macro enregistrée. Vous pouvez
exécuter la macro GrasItalique, soit à partir de la boîte de dialogue Macros, soit en utilisant le
raccourci clavier que vous lui aurez attribué après coup.
Vous savez maintenant enregistrer (selon la méthode de votre choix) et créer une macro. Si
GrasItalique vous paraît anodine, sachez que les principes acquis ici sont valables pour toutes
les macros, quelle que soit l’application hôte.
GrasItalique est une véritable commande que vous avez ajoutée à Excel. En procédant de la même
façon, vous pouvez créer n’importe quelle commande, en fonction de vos besoins.
Info
Vous avez appris dans ce chapitre à enregistrer et à créer une macro. La mise en œuvre de macros com-
plexes nécessite souvent de combiner ces deux méthodes. On enregistre en général les commandes de la
macro, puis on y écrit les fonctions qui ne peuvent être enregistrées.
Astuce
Pour qu’une macro s’exécute automatiquement à l’ouverture d’un classeur, affectez-lui le nom Auto_Open.
Cette fonction est intéressante si vous souhaitez paramétrer différemment Excel selon les classeurs affi-
chés. Enregistrez simplement les options d’Excel dans une macro Auto_Open.
Pour qu’une macro s’exécute automatiquement à la fermeture d’un classeur, affectez-lui le nom Auto_Close.
Vous pouvez ainsi mettre à jour un autre fichier, créer une sauvegarde du fichier dans un autre dossier,
afficher un message à l’attention de l’utilisateur, etc.
Classeurs et modèles
Les macros enregistrées dans Excel sont stockées dans des classeurs ou dans des modèles. Pour
accéder à une macro, il faut que le classeur dans lequel elle est stockée soit ouvert. Si plusieurs
classeurs sont ouverts, vous pouvez accéder aux macros de l’un d’entre eux à partir de n’importe
quel autre classeur.
Les macros enregistrées dans un modèle sont accessibles lorsque vous créez un nouveau classeur
fondé sur ce modèle (en choisissant la commande Nouveau de l’onglet Fichier et en sélectionnant
un modèle). Lorsque vous enregistrez le nouveau classeur, les macros du modèle sont « copiées »
dans celui-ci et restent donc disponibles par la suite, lorsque vous rouvrez le classeur.
Découvrir la programmation Excel
48 Première partie
Notez cependant que les classeurs Excel n’entretiennent pas de lien avec le modèle à partir
duquel ils ont été créés. Si vous ajoutez, modifiez ou supprimez des macros dans un modèle, ces
changements ne seront pas effectifs pour les classeurs préalablement créés à partir du modèle.
Pour enregistrer ou créer une macro dans un modèle, vous devez ouvrir le modèle en question.
Les classeurs dans lesquels sont stockées les macros sont identifiés par une extension spécifique :
.xltm ou .xlsm.
Figure 2-13 – Le classeur de macros personnel est créé lorsque vous quittez Excel
après y avoir enregistré ou écrit votre première macro.
Le classeur de macros personnel est ouvert chaque fois que vous exécutez Excel. Vous pouvez
donc en exécuter les macros qui y sont stockées à partir de n’importe quel classeur.
Info
Par défaut, le classeur de macros personnel est masqué au lancement d’Excel. Pour y accéder, choisissez
la commande Afficher de l’onglet Affichage et sélectionnez PERSONAL.XLSB dans la boîte de dialogue
Afficher.
Conseil
Le classeur de macros personnel est stocké dans le dossier XLSTART. Ce classeur contiendra probable-
ment l’essentiel de vos macros. Il est donc conseillé d’en effectuer régulièrement une sauvegarde. Par
défaut, l’emplacement de ce fichier est :
\Users\Nom_utilisateur\AppData\Roaming\Microsoft\Excel\XLSTART
Premières macros
Chapitre 2
49
Activer/désactiver un complément
Pour activer ou désactiver une macro complémentaire, procédez comme suit :
1. Cliquez sur l’onglet Fichier, puis sur le bouton Options. Dans la fenêtre qui s’affiche, sélec-
tionnez Compléments dans le volet gauche. La fenêtre représentée à la figure 2-15 s’affiche.
Cliquez sur le bouton Atteindre à côté de la zone Gérer.
Les compléments sont affichés. Les compléments actifs sont cochés.
2. Cliquez sur le bouton Parcourir. Si vous avez enregistré le complément dans le dossier proposé
par défaut, il apparaît dans la liste. Sélectionnez le fichier voulu et validez.
3. Cochez ou décochez le complément. Le nom et le descriptif qui apparaissent dans la boîte de
dialogue Compléments sont ceux qui ont été indiqués comme titre et commentaire du fichier
(voir figure 2-16).
Info
Vous pouvez également accéder aux compléments Excel via la commande éponyme de l’onglet
Développeur.
Premières macros
Chapitre 2
51
Conseil
Avant de vous lancer dans des activités de programmation complexes, vérifiez s’il n’existe pas un complé-
ment intégré répondant à vos besoins.
Figure 2-15 – Votre complément apparaît maintenant parmi la liste des compléments d’Excel.
Découvrir la programmation Excel
52 Première partie
• Nom_Classeur. Vous pouvez aussi choisir de ne visualiser que les macros de l’un des classeurs
ouverts, en sélectionnant simplement son nom dans la liste.
Attention
Si vous fermez le classeur personnel, vous ne pourrez plus accéder aux macros qui y sont stockées, ni y
enregistrer de nouvelles macros. Le classeur personnel s’ouvrira de nouveau lors de la prochaine session
Excel. Pour enregistrer des macros d’accès global ou accéder à celles du classeur personnel au cours de
la session active, vous devez rouvrir PERSONAL.XLSB.
Astuce
Le classeur PERSONAL.XLSB s’ouvre à l’exécution d’Excel parce qu’il se trouve dans le dossier XLSTART
(ou XLOuvrir selon la version d’Office). Pour ouvrir automatiquement un classeur au lancement d’Excel,
créez un raccourci vers ce classeur et placez-le dans ce dossier.
3
Déplacement et sélection
dans une macro Excel
Figure 3-1 – Vous pouvez enregistrer vos déplacements par référence relative ou absolue aux cellules.
Clavier
L’enregistrement de déplacements dans une feuille Excel par référence relative aux cellules néces-
site, dans certains cas, que vous utilisiez le clavier (par exemple, si vous souhaitez activer la
dernière cellule non vide d’une ligne). Le tableau 3-1 présente les différentes possibilités.
Attention
Lors de l’enregistrement d’une macro par référence absolue aux cellules, c’est l’adresse des cellules qui
est mémorisée. Pour un déplacement relatif (par exemple, la dernière cellule non vide de la ligne courante),
vous devez activer l’enregistrement par référence relative aux cellules en cliquant sur le bouton correspon-
dant de la barre d’outils Arrêt de l’enregistrement.
Pour étendre la sélection de la cellule active à une cellule donnée de la feuille, utilisez l’une des
combinaisons de touches présentées dans le tableau 3-1, en maintenant la touche Maj enfoncée.
Pour sélectionner les colonnes entières correspondant aux cellules sélectionnées, utilisez le rac-
courci clavier Ctrl+Barre d’espace ; pour sélectionner les lignes entières, utilisez Maj + Barre
d’espace.
Notez que, pour sélectionner des zones non contiguës, vous devez obligatoirement utiliser la souris.
Souris
Pour sélectionner une cellule, cliquez dessus. Pour sélectionner une ligne ou une colonne, cliquez
sur son en-tête.
Pour sélectionner des cellules adjacentes, cliquez sur la première cellule de la plage puis, tout en
appuyant sur la touche Maj, cliquez sur la dernière cellule. Pour sélectionner des lignes ou des
colonnes adjacentes, procédez de la même façon, en cliquant sur leurs en-têtes.
Pour sélectionner des cellules non contiguës, cliquez sur la première cellule puis, tout en appuyant
sur la touche Ctrl, cliquez successivement sur les autres cellules. Pour sélectionner des lignes ou
des colonnes non contiguës, procédez de la même façon, en cliquant sur leurs en-têtes.
Il est possible de combiner la sélection d’éléments non contigus de la feuille en maintenant la
touche Ctrl enfoncée et en cliquant sur les éléments voulus. Vous pouvez, par exemple, sélectionner
simultanément la colonne C, la ligne 5 et la cellule F4 : cliquez sur l’en-tête de la colonne C puis,
tout en appuyant sur la touche Ctrl, cliquez sur l’en-tête de la ligne 5 et enfin sur la cellule F4.
Figure 3-2 – Dans une plage de cellules Excel, une seule est la cellule active.
Attention
La référence aux cellules (relative ou absolue) active au moment où vous interrompez l’enregistrement
d’une macro sera aussi la référence active si vous enregistrez une nouvelle macro dans la même session
Excel (sans avoir quitté, puis relancé l’application). Lorsque vous enregistrez une macro, pensez toujours à
vérifier la référence avant de commencer à vous déplacer dans la feuille.
Découvrir la programmation Excel
60 Première partie
Pour sélectionner une cellule ou une plage, la feuille doit être active. Si tel n’est pas le cas, com-
mencez par activer la feuille voulue à l’aide de la méthode Activate. Les instructions permettant
de sélectionner la cellule B5 de la feuille intitulée Janvier du classeur Ventes.xlsx – sans qu’il soit
nécessaire que Janvier soit la feuille active – sont les suivantes :
Workbooks("Ventes.xlsx").Sheets("Janvier").Activate
Range("B5").Select
Info
Nous considérerons dans la suite de ce chapitre que la sélection s’effectue sur la feuille active et omettrons
donc toute instruction d’activation.
Astuce
La propriété Cells permet aussi de coder une référence absolue à une cellule. Elle s’utilise avec la syntaxe
suivante :
Cells(ligne, colonne)
où ligne est l’index de ligne et colonne l’index de colonne, tous deux exprimés par un chiffre – l’argument
colonne prend la valeur 1 pour la colonne A, 2 pour la colonne B, etc. Les expressions Cells(2,5).Select
et Range("E2").Select sont donc strictement équivalentes. Lorsque vous enregistrez un déplacement par
référence absolue aux cellules, il est toujours codé à l’aide de la propriété Range. La propriété Cells offre
l’avantage de pouvoir faire référence à des cellules à l’aide de variables numériques – les variables sont
traitées au chapitre 6.
Lorsque vous sélectionnez une plage de cellules, le code Visual Basic généré se présente ainsi :
Range("Cell1:Cell2").Select
Range("Cell_Active").Activate
revient à sélectionner une plage dont les cellules situées aux angles supérieur gauche et inférieur
droit sont respectivement B5 et D10. Cependant, cette sélection a été effectuée en partant de D5 et
en étendant la plage jusqu’à B10, si bien que la cellule active de la sélection est D5 (voir figure 3-4).
Découvrir la programmation Excel
62 Première partie
où les arguments Cell1 à Celln représentent les cellules successivement sélectionnées. Lors de
l’enregistrement d’une macro, l’argument Cell_Active représente la dernière cellule sélectionnée.
Par exemple, l’expression Visual Basic suivante :
Range("B5, D10, F2, A3").Select
Range("A3").Activate
revient à sélectionner successivement les cellules B5, D10, F2 et A3 en maintenant la touche Ctrl
enfoncée.
Rappel
Pour sélectionner une colonne ou une ligne dans une feuille Excel, cliquez sur son en-tête ou utilisez l’un
des raccourcis clavier présentés dans le tableau 3-1. Pour des colonnes ou des lignes contiguës, sélec-
tionnez la première ligne/colonne, puis enfoncez la touche Maj et cliquez sur la dernière ligne/colonne de
la plage.
Déplacement et sélection dans une macro Excel
Chapitre 3
63
Lignes contiguës
La syntaxe de la propriété Rows est la suivante :
Rows("ligne1:ligne2").Select
Range("cell_active").Activate
Info
Lorsque vous définissez une plage de lignes, la cellule active est la première cellule de la première ligne
que vous sélectionnez. Par exemple, si, lors de l’enregistrement d’une macro, vous sélectionnez la ligne 5,
puis maintenez la touche Maj enfoncée et sélectionnez la ligne 10, c’est la cellule A5 (située à l’angle supé-
rieur gauche de la plage) qui sera active. En revanche, si vous sélectionnez la ligne 10, puis la 5, c’est la
cellule A10 qui sera active.
Si la sélection ne porte que sur une ligne, les arguments ligne1 et ligne2 ont la même valeur
et l’expression Range("cell_active").Activate est omise. Par exemple, si vous enregistrez dans
une macro la sélection de la ligne 5 de la feuille active, le code Visual Basic correspondant se
présentera ainsi :
Rows("5:5").Select
Figure 3-5 – Lorsqu’une seule ligne est sélectionnée, le code ne spécifie pas de cellule active.
Si vous sélectionnez les lignes 5 à 10 en commençant par la 5, le code Visual Basic correspondant
se présentera ainsi :
Rows("5:10").Select
Découvrir la programmation Excel
64 Première partie
Si vous sélectionnez la même plage, mais en commençant par la ligne 10 (figure 3-6), le code
Visual Basic correspondant se présentera ainsi :
Rows("5:10").Select
Range("A10").Activate
Lorsque vous sélectionnez une ligne, la cellule active est par défaut la première de la ligne. Si vous
modifiez la cellule active – dans ou hors de la plage sélectionnée – en maintenant la touche Ctrl
enfoncée et en cliquant sur la cellule que vous souhaitez activer, la propriété Range se substitue à
la propriété Rows. Votre code se présente alors ainsi :
Range("ligne1:ligne2, cell_active").Select
Range("cell_active").Activate
où l’argument cell_active représente l’adresse de la cellule active. Par exemple, si vous sélec-
tionnez la ligne 14, puis maintenez la touche enfoncée et cliquez sur la cellule B14 lors de l’enre-
gistrement d’une macro, le code Visual Basic correspondant se présentera ainsi :
Range("14:14, B14").Select
Range("B14").Activate
Colonnes contiguës
La syntaxe de la propriété Columns est la même que celle de Rows :
Columns("col1:col2").Select
Range("cell_active").Activate
Si vous sélectionnez les colonnes B à E en commençant par B, le code Visual Basic correspondant
se présentera ainsi :
Columns("B:E").Select
Si vous sélectionnez la même plage, mais en commençant par E, le code Visual Basic corres-
pondant se présentera ainsi :
Columns("B:E").Select
Range("E1").Activate
Lorsque vous sélectionnez une colonne, la cellule active est par défaut la première de la colonne.
Si vous modifiez la cellule active – dans ou hors de la plage sélectionnée – en maintenant la
touche Ctrl enfoncée et en cliquant sur la cellule que vous souhaitez activer, la propriété Range se
substitue à la propriété Columns. Votre code se présente alors ainsi :
Range("col1:col2, cell_active").Select
Range("cell_active").Activate
où l’argument cell_active représente l’adresse de la cellule active. Par exemple, si vous sélec-
tionnez la colonne E, puis maintenez la touche Ctrl enfoncée et cliquez sur la cellule E5 lors de
l’enregistrement d’une macro, le code Visual Basic correspondant se présentera ainsi :
Range("E:E, E5").Select
Range("E5").Activate
Découvrir la programmation Excel
66 Première partie
Info
Vous pouvez substituer la propriété Range à Rows et Columns dans le code de votre macro, en conservant
les mêmes arguments. Par exemple, les expressions Range("5:10").Select et Rows("5:10").Select
correspondent toutes deux à la sélection des lignes 5 à 10 de la feuille active. Lors de l’enregistrement de
macros, les sélections sont codées différemment de façon à faciliter la lecture du code.
Les arguments item représentent les index des lignes ou colonnes sélectionnées. Ces arguments
vont par paires, chaque paire représentant une plage de lignes ou de colonnes contiguës sélec-
tionnées – le signe : est utilisé comme séparateur. Les arguments item d’une paire peuvent avoir
une même valeur.
Si, par exemple, vous sélectionnez les colonnes A, C à E et G et si G1 est la cellule active, la
syntaxe Visual Basic représentant cette sélection se présentera ainsi :
Range("A:A,C:E,G:G").Select
Range("G1").Activate
Déplacement et sélection dans une macro Excel
Chapitre 3
67
Info
Si, lors de l’enregistrement d’une macro, vous sélectionnez successivement des lignes ou des colonnes
contiguës en maintenant la touche Ctrl enfoncée, plutôt que d’utiliser la touche Maj, ces sélections seront
considérées comme autonomes et codées comme si les lignes ou les colonnes n’étaient pas contiguës.
Par exemple, si vous cliquez sur l’en-tête de la colonne A puis, tout en maintenant la touche Ctrl enfoncée,
cliquez successivement sur les en-têtes des colonnes B, C et E, le code Visual Basic correspondant se
présentera ainsi :
Range("A:A,B:B,C:C,E:E").Select
Range("C1").Activate
Si vous effectuez la même sélection en utilisant la touche Maj, le code correspondant se présente alors
ainsi :
Range("A:C,E:E").Select
Range("C1").Activate
Vous pouvez, en utilisant les mêmes méthodes de sélection, définir une plage composée de lignes
et de colonnes, contiguës ou non. Par exemple, si vous sélectionnez (à l’aide des touches Maj et
Ctrl) les colonnes C à E, la colonne G, les lignes 4 à 6 et la ligne 8 comme indiqué à la figure 3-10,
le code de votre macro se présentera ainsi :
Range("C:E,G:G,4:6,8:8").Select
Range("A8").Activate
Enfin, vous pouvez conjuguer la sélection de lignes, colonnes et cellules contiguës ou non. Le
code suivant indique la même sélection, à laquelle on a ajouté les cellules B13 et A2 à F2.
Range("C:E,G:G,4:6,8:8,A2:F2,B13").Select
Range("B13").Activate
Découvrir la programmation Excel
68 Première partie
revient à étendre la sélection de la cellule active jusqu’à celle située trois lignes au-dessus. On
obtient alors une sélection équivalente à A1:A4 (il peut s’agir de B1:B4, C5:C8, etc.)
où A1 représente la cellule active et les arguments Cell2 à Celln sont les adresses des cellules
successivement sélectionnées, par position relative à la cellule initiale. L’argument Cell_Active
représente la dernière cellule sélectionnée.
Info
Lors de déplacements par référence relative aux cellules, le codage Visual Basic se fait par style de réfé-
rence A1. Cela signifie que l’adresse virtuelle A1 est toujours attribuée à la cellule active, ce qui permet de
représenter les déplacements et sélections d’autres cellules par rapport à cette adresse virtuelle.
indique que la macro sélectionnera simultanément la cellule active (virtuellement A1) et celles dont
les adresses virtuelles (en style de référence A1) sont A7, C7 et C1. La cellule active (virtuelle-
ment C1) sera celle située deux colonnes à droite – Offset(0,2) – de la cellule initialement active.
Si la cellule active au moment de l’exécution de la macro est B5, les cellules B5, B11, D11 et D5
seront sélectionnées. D5 sera la cellule active.
Pour bien comprendre ce principe, gardez à l’esprit que ce qui fait la relativité du déplacement
est le repère d’origine. Les adresses des cellules sont déterminées par l’adresse de celle servant
de repère.
Découvrir la programmation Excel
70 Première partie
où expression renvoie l’objet Range à redimensionner. RowSize et ColumnSize, facultatifs, sont res-
pectivement les nombres de lignes et de colonnes qui doivent être ajoutées (valeurs positives) ou
retirées (valeurs négatives) à la sélection. Si l’un ou l’autre de ces arguments est omis, il prend la
valeur par défaut de 0 et la dimension correspondante n’est pas modifiée.
L’instruction suivante étend la sélection en cours d’une ligne et d’une colonne supplémentaires.
Elle utilise pour cela la propriété Count qui, appliquée aux collections Rows et Columns, renvoie
respectivement les nombres de lignes et de colonnes.
Selection.Resize(Selection.Rows.Count + 1, Selection.Columns.Count + 1).Select
La propriété CurrentRegion
Pour étendre la sélection à la zone courante, c’est-à-dire à la zone entourée par une combinaison
de lignes et de colonnes vides, vous utiliserez la propriété CurrentRegion selon la syntaxe suivante :
Range.CurrentRegion.Select
La première instruction étend la sélection à la zone courante à partir de la cellule active, tandis
que la seconde procède de même, mais à partir de la cellule C8 (figure 3-11).
Déplacement et sélection dans une macro Excel
Chapitre 3
71
La propriété End
La propriété End renvoie un objet Range qui représente la dernière cellule d’une zone. Cela revient
à employer dans un tableau Excel la combinaison clavier Fin+flèche de direction. Utilisez la
propriété End selon la syntaxe suivante :
Range.End(Direction)
où Range renvoie l’objet Range à partir duquel on recherche la dernière cellule non vide et où
Direction représente le sens dans lequel on se déplace. Il peut s’agir de l’une des constantes
xlDirection suivantes :
• xlDown. Déplacement vers le bas ;
• xlToRight. Déplacement vers la droite ;
• xlToLeft. Déplacement vers la gauche ;
• xlUp. Déplacement vers le haut.
Appliquées au tableau de la figure 3-11, les quatre instructions suivantes renvoient respectivement
l’objet Range représentant les cellules E4, E12, C8 et H8.
Range("E8").End(xlUp).select 'renvoie la cellule E4
Range("E8").End(xlDown).select 'renvoie la cellule E12
Range("E8").End(xlToLeft).select 'renvoie la cellule C8
Range("E8").End(xlToRight).select 'renvoie la cellule H8
Découvrir la programmation Excel
72 Première partie
Vous pouvez évidemment utiliser la propriété End pour sélectionner des plages de cellules, comme
nous l’avons vu précédemment dans ce chapitre. Considérez les exemples suivants.
• Sélection d’une plage de la première à la dernière cellule non vide d’une colonne :
Range("A1", Range("A1").End(xlDown)).Select
Range(ActiveCell, ActiveCell.End(xlDown)).Select
Si vous souhaitez sélectionner la première cellule vide d’une zone plutôt que la dernière cellule
non vide, utilisez la propriété Offset pour décaler la sélection. La première instruction, ci-après,
sélectionne la première cellule vide au bas de la colonne, tandis que la seconde sélectionne la
première cellule vide à droite :
Range("A1").End(xlDown).Offset(1,0).Select
Range("A1").End(xltoRight).Offset(0,1).Select
La propriété UsedRange
La propriété UsedRange retourne la plage de cellules contenant les données d’une feuille. Cette
propriété est donc particulièrement pratique pour identifier les cellules sur lesquelles doivent
s’appliquer des traitements lors de l’exécution d’un programme. La plage retournée par UsedRange
est un ensemble de cellules contiguës dont les limites sont définies par :
• la cellule dont l’index de colonne est le plus élevé ;
• la cellule dont l’index de colonne est le plus faible ;
• la cellule dont l’index de ligne est le plus élevé ;
• la cellule dont l’index de ligne est le plus faible.
L’instruction suivante sélectionne la plage de cellules utilisée sur la feuille active du classeur actif :
ActiveWorkbook.ActiveSheet.UsedRange.Select
L’exemple suivant passe en gras les cellules de la plage nommée MaPlage, située sur la feuille
Feuil1 du classeur Test.xlsx :
Range("[Test.xlsx]Feuil1!MaPlage").Font.Bold = True
Déplacement et sélection dans une macro Excel
Chapitre 3
73
Figure 3-12 – La propriété UsedRange retourne une plage qui englobe toutes les cellules contenant des données.
Pour sélectionner une plage nommée, utilisez la méthode GoTo qui active successivement le clas-
seur et la feuille si nécessaire, puis sélectionne la plage voulue. Les deux instructions suivantes
sélectionnent la plage nommée MaPlage, puis en effacent le contenu :
Application.Goto Reference:="[Test.xlsx]Feuil1!MaPlage"
Selection.ClearContents
4
Découvrir Visual Basic Editor
Visual Basic Editor est l’environnement de développement intégré de VBA. C’est dans cet envi-
ronnement que vous passerez l’essentiel de votre temps lors du développement de projets VBA.
Les chapitres précédents vous ont fait découvrir la fenêtre Code à travers la modification et la
création de macros. Toutefois, Visual Basic Editor ne se résume pas à un simple éditeur de code.
Il s’agit d’un logiciel complet proposant des outils d’aide au développement, que ce chapitre vous
propose de découvrir.
Info
Lorsque vous êtes dans Visual Basic Editor, vous pouvez accéder à l’ensemble des éléments constitutifs
des projets accessibles, y compris aux macros disponibles dans la boîte de dialogue Macro.
Découvrir la programmation Excel
76 Première partie
Attention
Pour qu’un projet soit accessible dans Visual Basic Editor, il faut que le document dans lequel il est stocké
soit ouvert dans l’application hôte.
Activez l’onglet Développeur du ruban, puis sélectionnez Visual Basic Editor, ou tapez le rac-
courci clavier Alt+F11.
Rappel
L’onglet Développeur n’est pas activé par défaut. Pour l’afficher, rendez-vous sur la page Options et choi-
sissez Personnaliser le ruban. Cochez la case Onglet développeur, puis validez.
La figure 4-3 présente la fenêtre de Visual Basic Editor. Il se peut que, sur votre ordinateur, elle
ne propose pas les mêmes éléments. Vous verrez par la suite comment en afficher les différents
composants.
Conseil
Dans bien des cas, l’enregistrement de macros reste la méthode la plus rapide et la plus sûre pour démar-
rer vos projets VBA. En laissant à l’Enregistreur de macro le soin de convertir les actions exécutées en
code Visual Basic, vous êtes assuré de ne pas commettre d’erreur de saisie.
Il se peut cependant que la première étape du développement de votre projet consiste à créer une feuille
permettant une interaction avec l’utilisateur. Vous accéderez alors directement à Visual Basic Editor, sans
passer par la boîte de dialogue Macro.
Pour quitter Visual Basic Editor et retourner à l’application hôte, vous pouvez :
• ouvrir le menu Fichier, sélectionner la commande Fermer et retourner à Microsoft Excel ;
• taper le raccourci clavier Alt+Q ;
• cliquer sur la case de fermeture de Visual Basic Editor (située à l’extrémité supérieure droite
de la fenêtre).
Pour retourner à l’application hôte sans quitter Visual Basic Editor, vous pouvez :
cliquer sur l’icône Affichage Microsoft Excel, située à l’extrême gauche de la barre d’outils
Standard ;
taper le raccourci clavier Alt+F11.
Découvrir la programmation Excel
78 Première partie
Cette section présente sommairement les éléments essentiels de l’interface. Vous en découvrirez
plus précisément les fonctionnalités au fur et à mesure que vous avancerez dans la lecture de
l’ouvrage :
• L’Explorateur de projet. Il expose les différents projets et leurs éléments constitutifs – objets,
modules, modules de classe, feuilles (ou formulaires) et Référence – et donne accès à ces
éléments ou au code qui leur est attaché. Pour qu’un projet apparaisse dans l’Explorateur de
projet, il faut que le document auquel il est attaché soit ouvert dans l’application hôte.
• La fenêtre Propriétés. Elle sert à visualiser et modifier l’ensemble des propriétés associées aux
objets constitutifs d’un projet.
• La fenêtre Code. Vous pouvez y éditer le code de vos projets. Visual Basic Editor propose des
aides à l’écriture de code et des outils de débogage.
• La fenêtre UserForm et la boîte à outils. La fenêtre UserForm est l’espace dans lequel vous
concevez les feuilles VBA. La boîte à outils propose des contrôles communs tels que des cases
à cocher ou des listes déroulantes à placer sur une feuille qui constituera une interface pour
votre application.
Découvrir Visual Basic Editor
Chapitre 4
79
L’Explorateur de projet
L’Explorateur de projet expose les différents projets chargés dans l’application hôte et les éléments
qui les composent. Il donne accès à n’importe quel élément constitutif d’un projet et autorise la
création de nouveaux éléments ou, au contraire, leur suppression.
Figure 4-5 – L’Explorateur de projet facilite l’accès aux différents éléments constitutifs d’un projet.
Attention
Si un projet ne contient aucun module ou module de classe, les dossiers correspondants n’apparaîtront
pas dans l’Explorateur de projet.
Info
Lorsque vous créez une macro, elle est enregistrée dans un nouveau module accessible via le dossier
Modules du projet correspondant. Son nom est Module1, Module2 si Module1 existe déjà, etc.
Le signe plus (+) développe l’arborescence d’un dossier ou d’un projet et le signe moins (–) la réduit.
Plutôt que par dossiers, les éléments constitutifs d’un projet peuvent être présentés par ordre
alphabétique. Cliquez simplement sur le bouton Basculer dossiers de l’Explorateur de projet. La
figure 4-7 présente l’aspect après masquage des dossiers. Pour revenir à l’affichage précédent,
cliquez de nouveau sur ce bouton.
Modules de code
Feuilles
Référence
Figure 4-7 – Lorsque l’affichage des dossiers est désactivé, les icônes distinguent les éléments du projet.
Afficher l’objet Affiche l’objet sélectionné dans l’Explorateur de projet. Il peut s’agir d’une feuille (dossier
UserForm) ou d’un document. Ce bouton est désactivé si l’objet sélectionné est un
module de code.
Découvrir la programmation Excel
82 Première partie
L’Explorateur d’objets
Lorsqu’on commence à développer en VBA, la difficulté essentielle consiste à manipuler les objets
de l’application hôte (dans notre cas les objets Excel). Comment, par exemple, accéder à une plage
de cellules d’une feuille spécifique d’un classeur et y insérer une formule ? L’Enregistreur de macro
est dans de nombreux cas la solution à ce problème. Vous manipulez les objets Excel après avoir
activé l’Enregistreur de macro, puis vous visualisez dans Visual Basic Editor les mots-clés Visual
Basic utilisés pour accéder aux objets, à leurs propriétés et à leurs méthodes.
Cependant, certains éléments de code d’un programme VBA ne peuvent être générés à l’aide de
l’Enregistreur de macro et doivent être saisis dans la fenêtre Code du programme. Il vous faut
alors connaître la position de l’objet auquel vous souhaitez accéder dans la hiérarchie de classes
de l’application. Vous devez aussi connaître les méthodes et propriétés associées à cet objet pour
pouvoir le manipuler ou en extraire des informations.
Les chapitres précédents vous ont initié à la syntaxe VBA permettant d’accéder à un objet. Pour
autant, lorsque vous commencerez à développer dans Visual Basic Editor, vous ne connaîtrez
pas toujours le chemin à emprunter pour accéder à tel ou tel objet, ni la méthode à lui appliquer
pour effectuer telle ou telle opération. L’Explorateur d’objets constitue pour cela une aide très
appréciable pour le développeur, en supplément de l’Aide de VBA. Il recense en effet l’ensemble
des objets disponibles dans les bibliothèques d’objets accessibles pour un projet, ainsi que les
propriétés, constantes, méthodes et événements associés.
Définition
Une bibliothèque d’objets est un fichier contenant toutes les données des objets (leurs propriétés, méthodes,
événements, constantes, etc.). Ce fichier porte l’extension .OLB, et c’est à lui que se réfère Visual Basic
lorsque vous manipulez des objets Excel. Le nom de fichier de la bibliothèque d’objets d’Excel ainsi que son
emplacement varient d’une version à l’autre. Pour le localiser, effectuez une recherche sur * .olb.
Lorsque vous recherchez un objet ou souhaitez en connaître les membres – c’est ainsi que l’on
nomme les éléments Visual Basic (méthodes, propriétés, événements, constantes) associés –,
l’Explorateur d’objets vous fournit une documentation complète. Il donne accès au modèle d’objets
de l’application hôte, mais aussi à ceux d’autres applications et aux objets, procédures et constantes
que vous avez créés dans le cadre de votre projet, ainsi qu’aux rubriques d’aide associées à chacun
de ces éléments.
Liste
Classes
Liste Membres
Zone
Détails
Figure 4-8 – L’Explorateur d’objets sert à explorer l’ensemble des objets disponibles pour un projet.
La liste Projet/Bibliothèque
La liste déroulante Projet/Bibliothèque sert à sélectionner le projet ou la bibliothèque d’objets de
votre choix. Le tableau 4-1 présente les bibliothèques les plus courantes.
Bibliothèque Description
<Toutes Lorsque cette option est sélectionnée, les objets sont affichés, toutes bibliothèques
bibliothèques> confondues.
MSForms Contient les objets accessibles dans la fenêtre UserForm, tels que les boutons d’options, cases
à cocher, listes déroulantes, etc.
Office Contient les objets Microsoft Office. Il s’agit des objets communs aux applications Office.
Découvrir la programmation Excel
84 Première partie
Bibliothèque Description
VBA Il s’agit de la bibliothèque Visual Basic pour Applications. Les objets y sont classés par thème.
Par exemple, le module Information contient les procédures pour renvoyer et vérifier des
informations et le module String contient les procédures effectuant des opérations sur des
chaînes de caractères.
Excel Contient les objets d’Excel.
Autres Contient les objets des autres applications référencées dans votre projet. Référencer une autre
applications application donne accès à ses objets à partir d’Excel. Vous verrez au chapitre 6 comment créer
une référence à la bibliothèque d’objets d’une autre application et comment en manipuler les
objets.
Projets Affiche les objets propres au projet, tels que les feuilles, les modules de classe et les modules
de code que vous avez créés.
Lorsque vous sélectionnez une classe dans la zone de gauche, tous ses membres apparaissent
dans celle de droite, affichés par type (propriétés, constantes, méthodes et événements) et par
ordre alphabétique au sein de chaque type. Chaque type de membre est symbolisé par une icône.
Lorsqu’un membre contient du code rédigé par l’utilisateur, son nom apparaît en gras.
Découvrir Visual Basic Editor
Chapitre 4
85
Définition
On appelle membres d’une classe l’ensemble des éléments référencés pour cette classe, c’est-à-dire ses
propriétés, constantes, méthodes et événements.
Astuce
Pour afficher les membres d’une classe par ordre alphabétique, indépendamment de leur type, cliquez-
droit dans l’Explorateur d’objets et, dans le menu contextuel qui s’affiche, sélectionnez la commande
Membres du groupe. Pour revenir à un affichage par groupe, répétez cette opération.
Figure 4-10 – L’Explorateur d’objets facilite l’accès aux rubriques d’aide des objets affichés.
Découvrir la programmation Excel
86 Première partie
Membres de Range
Le bouton Afficher la définition est accessible lorsque la classe ou le membre de classe sélectionné
contient du code rédigé. Il entraîne l’affichage de la fenêtre Code correspondant à la sélection en
cours dans l’Explorateur d’objets.
Découvrir Visual Basic Editor
Chapitre 4
87
Rechercher du texte
L’Explorateur d’objets offre un outil pour rechercher des chaînes de caractères dans les biblio-
thèques de votre choix. Procédez comme suit :
1. Dans la zone Bibliothèque/Projet, sélectionnez la bibliothèque ou le projet dans lequel vous
souhaitez que la recherche s’effectue.
Si vous ne savez pas où chercher, sélectionnez <Toutes bibliothèques>.
2. Dans la zone Rechercher texte, saisissez la chaîne de caractères que vous voulez.
Astuce
Si vous n’êtes pas certain de l’orthographe du texte à rechercher, utilisez les caractères génériques
suivants :
• * toute chaîne ;
• ? tout caractère.
3. Cliquez sur le bouton Rechercher. La zone Résultats de la recherche s’affiche. Pour chacun
des éléments trouvés, la bibliothèque, la classe et le membre sont indiqués (voir figure 4-12).
4. Si vous souhaitez afficher les résultats pour d’autres bibliothèques, modifiez simplement la
sélection dans la zone Bibliothèque/Projet. Les résultats sont automatiquement mis à jour.
5. Pour afficher les informations concernant l’un des résultats dans les zones Classe et Membres de,
sélectionnez l’élément voulu dans la zone Résultat de la recherche.
Les zones Classe et Membres de sont automatiquement mises à jour, les objets concernés par
la sélection étant entourés de pointillés (voir figure 4-13).
Découvrir la programmation Excel
88 Première partie
Le résultat sélectionné...
Figure 4-13 – Sélectionnez l’élément qui vous intéresse dans la zone Résultat de la recherche.
6. Pour ouvrir la rubrique d’aide associée à l’un des éléments trouvés, sélectionnez-le et cliquez
sur le bouton Aide, ou tapez le raccourci clavier F1.
7. Votre recherche terminée, vous pouvez choisir de masquer la zone de résultats. Pour cela,
cliquez simplement sur le bouton Afficher/Masquer les résultats de la recherche.
Pour afficher de nouveau cette zone sans lancer une nouvelle recherche, cliquez une nouvelle
fois sur le bouton.
La fenêtre UserForm
La fenêtre UserForm sert à dessiner des boîtes de dialogue pour vos projets. Dans Visual Basic
pour Applications, ces boîtes sont appelées feuilles – on parle aussi de formulaires. Une feuille
peut être très simple, ou présenter un grand nombre de fonctionnalités (figure 4-14).
Le développement de feuilles est un aspect essentiel de la programmation VBA. Les chapitres 12
à 14 sont entièrement consacrés à ce sujet. Cette section présente sommairement les possibilités
de développement dans la fenêtre UserForm.
On peut distinguer deux phases essentielles dans la création d’une interface utilisateur :
• le développement visuel de la feuille – traité au chapitre 13 ;
• l’association de code aux différents éléments de la feuille – traitée aux chapitres 13 et 14.
Découvrir Visual Basic Editor
Chapitre 4
89
La première phase consiste à dessiner la feuille, c’est-à-dire à créer l’interface dont vous avez
besoin pour votre application. Cette étape consiste essentiellement à placer des contrôles sur la
feuille et à en déterminer les positions respectives. Il s’agit des éléments constitutifs d’une fenêtre
tels qu’une case à cocher, une liste déroulante ou un bouton de commande permettant une inter-
vention de l’utilisateur. Un contrôle est un objet ; en tant que tel, il possède des propriétés, des
méthodes et des événements définis.
Par exemple, un contrôle Checkbox (case à cocher) possède une propriété Value indiquant son état
(True si la case est cochée, False si elle est décochée et Null si elle n’est ni cochée ni décochée
– grisée). La méthode SetFocus lui affecte le focus, c’est-à-dire en fait l’objet recevant les événe-
ments clavier ou souris. Enfin, un événement Click (un clic de souris) affectant cet objet peut être
détecté et entraîner un comportement spécifique de l’application, tel que le déclenchement d’une
procédure (appelée procédure d’événement).
Certains contrôles, dits interactifs, réagissent aux actions de l’utilisateur (un bouton OK déclen-
chant la validation des données de la feuille et le lancement d’une procédure) ; les autres, dits
statiques, ne sont accessibles qu’au niveau du code (un intitulé sur la feuille ne pouvant être
modifié par l’utilisateur).
La figure 4-15 présente la boîte de dialogue Police de Word, sur laquelle vous pouvez visualiser
différents types de contrôles.
Découvrir la programmation Excel
90 Première partie
Zone de texte ou
contrôle TextBox
Onglet ou
contrôle
TabStrip
Zone de liste
ou contrôle
ListBox
Zone de liste
modifiable ou
Case à cocher ou
contrôle
contrôle CheckBox
ComboBox
Intitulé ou
contrôle Label
Bouton de commande ou
contrôle CommandButton
Figure 4-15 – Les contrôles à placer sur une feuille sont les mêmes
que ceux que vous rencontrez dans les applications Office.
Par défaut, la boîte à outils propose les contrôles les plus couramment rencontrés dans l’application
hôte (voir figure 4-16). Vous verrez au chapitre 13 comment la personnaliser en y ajoutant des
contrôles ou en en modifiant l’ordonnancement.
Pour afficher/masquer la boîte à outils, une fenêtre UserForm doit être active :
• sélectionnez la commande Boîte à outils du menu Affichage ;
ou
• cliquez sur le bouton Boîte à outils de la barre d’outils Standard de Visual Basic Editor.
Vous verrez au chapitre 13 que Visual Basic Editor propose des outils facilitant grandement la
phase de développement visuel des feuilles.
La fenêtre Code
La fenêtre Code est l’éditeur de Visual Basic Editor. Elle sert à écrire, visualiser et modifier des
programmes Visual Basic. Toute action qu’exécute une application VBA existe sous forme de
code et l’ensemble des instructions qui constituent un projet est édité dans cette fenêtre.
Une fenêtre Code est toujours attachée à l’un des modules apparaissant dans l’Explorateur de
projet (voir figure 4-17). Il peut s’agir d’un module standard, d’un module de classe, d’une feuille
ou du document auquel est attaché le projet.
La fenêtre Code présente de nombreuses et précieuses fonctionnalités, destinées à faciliter le
développement de vos projets. Vous pouvez, par exemple, en ouvrir une pour chacun des modules
apparaissant dans votre projet et copier, coller ou déplacer des instructions d’une fenêtre et
d’une procédure à l’autre, rechercher des chaînes de caractères ou marquer certains endroits du
programme en y plaçant des signets, paramétrer la fenêtre afin que la syntaxe Visual Basic soit
vérifiée au fur et à mesure de la saisie du code, etc.
Info
Pour accéder au code des contrôles d’une feuille, double-cliquez dessus ou cliquez-droit et choisissez la
commande Code du menu contextuel qui s’affiche.
Découvrir la programmation Excel
92 Première partie
Figure 4-17 – Chacun des modules d’un projet possède une fenêtre Code.
Pour masquer la fenêtre Code, cliquez sur la case de fermeture ou cliquez-droit dans la fenêtre
et sélectionnez la commande Masquer du menu contextuel qui s’affiche.
Définition
Une procédure est un bloc d’instructions, tel qu’une macro, délimité par des mots-clés d’encadrement et
exécuté en tant qu’entité. Vous verrez au chapitre 5 qu’une procédure peut avoir pour fonction de renvoyer
une valeur ou d’exécuter un certain nombre d’actions. Le code exécutable des projets VBA est toujours
contenu dans des procédures.
Les éléments référencés dans la liste déroulante Procédure peuvent être des procédures ou des
événements, selon le type du module. La figure 4-21 présente la liste Procédure dans la fenêtre
Code du module LivreExcel ; toutes les procédures du projet y sont référencées, séparées par des
lignes grises.
Rappel
Lorsque vous enregistrez ou créez des macros dans Excel, elles sont stockées dans un module nommé
Modulen, accessible dans le dossier Modules de l’Explorateur de projet.
Dans le haut de la liste se trouve l’entrée (Déclarations). Il s’agit des déclarations générales du
module. Si la fenêtre Code est celle d’une feuille, (Général) doit être sélectionné dans la liste Objet
pour que (Déclarations) apparaisse dans la liste Procédure. Cette dernière référence l’ensemble des
événements (un clic de souris, une saisie au clavier, etc.) reconnus pour la feuille ou le contrôle
sélectionné dans la liste Objet (voir figure 4-22) et la fenêtre Code affiche la procédure d’événe-
ment correspondante. Si l’option (Général) est sélectionnée dans la liste Objet, la liste Procédure
répertorie l’ensemble des déclarations et des procédures de la feuille.
Définition
Une procédure d’événement (ou événementielle) est une procédure attachée à un événement spécifique,
tel qu’un clic de souris. Elle s’exécute lorsque l’événement est reconnu par le programme. Ce sujet est
traité au chapitre 15.
Lorsque vous sélectionnez une procédure dans la liste, son code apparaît dans le haut de la fenêtre
Code, le point d’insertion étant automatiquement placé sur la première ligne.
Cet objet... … gère ces événements
• Vous pouvez aussi vous déplacer ou effectuer des sélections de blocs de code à l’aide du clavier.
Pour atteindre la procédure précédente (resp. suivante), tapez le raccourci clavier Ctrl+Pg. Préc
(resp. Ctrl+Pg. Suiv). Pour étendre la sélection, utilisez les mêmes combinaisons de touches,
auxquelles vous ajouterez la touche Maj.
Astuce
En substituant les touches fléchées haut et bas aux touches Pg. Préc. et Pg. Suiv. dans les combinaisons
mentionnées, vous atteignez la première ligne de code sous la déclaration de procédure (Sub, Function
ou Property) plutôt que la déclaration de procédure elle-même.
Astuce
Une pression sur la touche F3 ou la commande Suivant du menu Édition relance la dernière recherche
effectuée sans ouvrir la boîte de dialogue Rechercher.
2. Indiquez le texte à rechercher et définissez l’étendue, le sens et les options de recherche. Dans
la zone Remplacer par, saisissez le texte de remplacement.
3. Si vous souhaitez effectuer le remplacement sur toutes les occurrences du texte recherché,
cliquez sur Remplacer tout.
Une boîte de dialogue vous indique le nombre de remplacements effectués.
4. Pour visualiser les occurrences de texte trouvées avant d’effectuer le remplacement, cliquez
sur le bouton Suivant pour lancer la recherche. Lorsque le texte est trouvé, il apparaît en sur-
brillance dans la fenêtre Code.
Pour remplacer l’occurrence sélectionnée, cliquez sur le bouton Remplacer. Le texte est remplacé
et la recherche se poursuit. Pour poursuivre sans remplacement, cliquez sur le bouton Suivant.
Il est aussi possible de séparer une fenêtre Code en deux volets, afin d’afficher simultanément
des sections non contiguës d’un même module. Vous pouvez ainsi copier, coller ou déplacer du
code d’une section à l’autre du module. Procédez comme suit :
1. Placez le curseur sur la barre de fractionnement située dans le haut de la barre de défilement
verticale de la fenêtre Code.
2. Lorsque le curseur se transforme en une double flèche, faites glisser la barre de fractionnement
vers le bas, jusqu’à atteindre la délimitation souhaitée pour les deux volets. Relâchez le bouton
de la souris.
Les deux volets étant autonomes (voir figure 4-28), vous pouvez modifier l’affichage de l’un ou
l’autre à l’aide des barres de défilement verticales. Les listes Objet et Procédure s’appliquent à la
fenêtre active, c’est-à-dire celle dans laquelle se trouve le point d’insertion.
Options d’affichage
L’affichage dans la fenêtre Code de Visual Basic Editor est personnalisable. Cette section présente
les options de paramétrage de la fenêtre ; celles du code sont présentées au chapitre 5.
Par défaut, la fenêtre Code affiche toutes les procédures du module, séparées par des traits gris
(voir figure 4-29).
Vous préférerez peut-être n’afficher qu’une procédure dans la fenêtre Code. Procédez comme suit :
1. Choisissez la commande Options du menu Outils. Sélectionnez l’onglet Éditeur de la boîte de
dialogue qui s’affiche (voir figure 4-30).
2. Cochez ou décochez les cases de la zone Paramètres de la fenêtre, en fonction du type d’affi-
chage souhaité :
– Glisser-déplacer pour l’édition de texte ;
– Affichage complet du module par défaut. Décochez cette case si vous souhaitez n’afficher
qu’une procédure (voir figure 4-31). Utilisez alors la liste déroulante Procédure pour sélec-
tionner celle que vous voulez ;
– Séparation des procédures. Dans le cas d’un affichage complet du module, cette option
détermine si un séparateur sera affiché ou non entre les différentes procédures.
Découvrir la programmation Excel
102 Première partie
Figure 4-31 – Vous pouvez choisir de n’afficher qu’une procédure dans la fenêtre Code.
Découvrir Visual Basic Editor
Chapitre 4
103
La fenêtre Propriétés
La fenêtre Propriétés concerne divers éléments d’un projet. Vous pouvez y visualiser et modifier
les propriétés d’un classeur ou d’une feuille de calcul, d’une feuille UserForm, d’un contrôle,
d’une classe, d’un projet ou d’un module. Vous l’utiliserez essentiellement lors du développement
de feuilles pour vos projets.
Info
Vous découvrirez les propriétés essentielles des contrôles que l’on place sur les feuilles UserForm et
apprendrez à les modifier aux chapitres 13 et 15.
Les propriétés varient en fonction de l’élément sélectionné. Ainsi, celles d’un contrôle en défi-
nissent l’aspect et le comportement (sa position, sa taille, le fait que l’utilisateur peut ou non
y apporter des modifications, etc.), tandis que celles d’un projet en définissent simplement le
nom. La figure 4-32 présente la fenêtre Propriétés d’un contrôle CheckBox (case à cocher), et la
figure 4-33 celle d’un projet.
La colonne gauche affiche La colonne droite affiche les
les noms des propriétés valeurs affectées aux propriétés
Info
Lorsque plusieurs contrôles sont sélectionnés sur une feuille, la fenêtre Propriétés affiche leurs propriétés
communes.
La fenêtre Propriétés présente deux onglets déterminant le type d’affichage des propriétés :
• Alphabétique. Toutes les propriétés recensées pour l’élément sélectionné sont affichées par
ordre alphabétique (voir figure 4-32) ;
• Par catégorie. Les propriétés de l’objet sélectionné sont regroupées par catégorie et, à l’inté-
rieur de chacune, par ordre alphabétique (voir figure 4-35). Les catégories apparaissent en
gras. À l’instar des dossiers de l’Explorateur, les propriétés qui y sont recensées peuvent être
affichées ou masquées lorsque vous cliquez sur les signes plus (+) ou moins (–).
Figure 4-35 – L’affichage par catégorie permet d’accéder rapidement aux propriétés voulues.
Découvrir la programmation Excel
106 Première partie
Astuce
Dans le cas des propriétés acceptant un booléen ou une constante, vous pouvez passer d’une valeur à la
suivante en double-cliquant simplement dans la case de valeur.
Cette section présente la barre d’outils Standard. Vous découvrirez les autres barres au fur et à
mesure de la lecture de cet ouvrage.
Il est possible de cliquer-déplacer une barre d’outils jusqu’à atteindre l’emplacement voulu, maté-
rialisé par un contour grisé.
Astuce
Pour obtenir des informations contextuelles sur les boutons d’une barre, sélectionnez la commande
Options du menu Outils et, dans l’onglet Général, cochez l’option Afficher les info-bulles.
Insertion En cliquant sur la flèche, vous ouvrez un menu permettant d’insérer l’un des
objets suivants dans le projet actif :
UserForm (feuille)
Module de classe
Module
Procédure
Le bouton représente le dernier objet ajouté (par défaut la feuille UserForm).
Enregistrer Enregistre le document hôte, y compris le projet et tous ses composants
<Document hôte> – feuilles et modules (raccourci clavier : Ctrl+S).
Répéter Chaque clic sur ce bouton rétablit la dernière action annulée. Pour qu’il soit
accessible, il faut qu’une action ait été annulée et qu’aucune modification
n’ait eu lieu depuis l’annulation.
Exécuter Sub/ Exécute une application fonction de la fenêtre active :
UserForm ou Exécuter • Fenêtre Code : la procédure en cours est exécutée.
la macro • Fenêtre UserForm : la feuille active est exécutée.
• Autre : ouvre la boîte de dialogue Macros du projet actif, à partir de laquelle
vous pouvez exécuter la macro de votre choix.
Arrêt Interrompt l’exécution en cours et bascule en mode Arrêt. En mode Arrêt,
vous pouvez relancer l’exécution d’une procédure, réinitialiser un projet,
tester un programme, etc. (raccourci clavier : Ctrl+Pause).
Réinitialiser Réinitialise le projet.
Découvrir la programmation Excel
110 Première partie
Boîte à outils Affiche la boîte à outils. Accessible uniquement si une fenêtre UserForm est
active.
Assistant Office Ouvre la fenêtre de l’Assistant Office, dans laquelle vous êtes invité à saisir
le sujet sur lequel vous souhaitez obtenir de l’aide (raccourci clavier : F1).
Définition
Une fenêtre est dite ancrée lorsqu’elle est fixée à la bordure d’une autre (celle de l’application ou une autre
fenêtre elle-même ancrée).
Une fenêtre ancrée demeure au premier plan. Si vous maximisez une fenêtre dans Visual Basic
Editor, celle-ci viendra épouser la fenêtre ancrée, sans en recouvrir l’espace. Vous pouvez ainsi
tirer pleinement parti de l’espace de Visual Basic Editor. À la figure 4-42, nous avons ancré
l’Explorateur de projet et maximisé une fenêtre Code.
Les fenêtres ancrables sont les suivantes :
• Exécution ;
• Variables locales ;
• Espions ;
• Explorateur de projet ;
• Propriétés ;
• Explorateur d’objets.
Découvrir Visual Basic Editor
Chapitre 4
111
Figure 4-42 – Ancrer l’Explorateur de projet facilite l’accès aux éléments de vos projets.
Lorsqu’une fenêtre est ancrée, elle se place automatiquement sur l’une des bordures de la fenêtre
de Visual Basic Editor quand vous la déplacez. Si vous souhaitez pouvoir la déplacer n’importe
où dans la fenêtre de Visual Basic Editor, désactivez-en l’ancrage.
Pour activer ou désactiver l’ancrage des fenêtres de Visual Basic Editor, choisissez l’une des
méthodes suivantes :
• Cliquez-droit dans la fenêtre de votre choix. Un menu contextuel s’affiche, fonction de la fenêtre
choisie. Sélectionner/désélectionner la commande Ancrable (figure 4-43) active ou désactive
l’ancrage de la fenêtre.
• Sélectionnez la commande Options du menu Outils et placez-vous sur l’onglet Ancrage (voir
figure 4-44). Cochez les cases des fenêtres que vous souhaitez ancrer et décochez les autres.
Cliquez sur OK.
Info
Si l’accès aux commandes de Visual Basic Editor ne convient pas à votre façon de travailler, personnalisez
les menus et les barres d’outils en y ajoutant/supprimant des commandes et des boutons. Vous pouvez
aussi créer une nouvelle barre d’outils ou un nouveau menu dans lesquels vous placerez les commandes
de votre choix. Pour connaître les procédures de personnalisation, reportez-vous au chapitre 12.
Découvrir la programmation Excel
112 Première partie
Astuce
Si, après avoir modifié l’emplacement des fenêtres, vous ne parvenez plus à en modifier l’organisation, une
seule solution s’offre à vous : exécutez l’éditeur de registre, et positionnez-vous dans la clé
HKEY_CURRENT_USER\Software\Microsoft\VBA\7.1\Common. Supprimez la référence Dock de type
REG_BINARY, puis relancez Excel. L’affichage des fenêtres de Visual Basic Editor est ainsi réinitialisé.
Deuxième partie
Programmer
en Visual Basic
5
Développer dans
Visual Basic Editor
Les chapitres précédents vous ont permis d’acquérir les concepts essentiels et de découvrir l’envi-
ronnement de développement Visual Basic Editor. Avec ce chapitre, nous entrons de plain-pied
dans la programmation VBA.
Vous apprendrez à distinguer les composants essentiels et à déterminer les besoins de votre projet.
Vous serez ainsi à même de le structurer de façon cohérente, lui assurant efficacité et lisibilité.
Gardez à l’esprit que les projets sont attachés à une application hôte, ici Excel. Vous devez donc
ouvrir Visual Basic Editor à partir d’Excel. Le classeur auquel est affecté (ou auquel vous sou-
haitez affecter) votre projet doit aussi être ouvert.
Les modules
Comme vous l’avez vu en découvrant l’Explorateur de projet, on distingue les modules standards
ou modules de code, les modules de classe et les feuilles. Autrement dit, les différents composants
du code d’un projet VBA sont structurés et distingués selon leur type. Ces éléments interagissent
et s’appellent pour constituer un programme complet.
Le code décrivant l’interface d’un programme et celui affecté aux différents événements qui
peuvent toucher cette interface (un clic de souris sur un bouton OK, par exemple) sont stockés
Programmer en Visual Basic
116 Deuxième partie
dans un fichier UserForm. Pour chaque feuille d’un projet, il existe un objet UserForm accessible
dans le dossier Feuilles de l’Explorateur de projet. Le projet de la figure 5-1 contient dix feuilles.
Figure 5-1 – À chaque feuille d’un projet est affecté un fichier dans le dossier Feuilles.
Le code standard se trouve dans des modules de code, stockés dans le dossier Modules, tandis
que le code décrivant les objets développés pour votre projet est stocké dans le dossier Modules
de classe.
Les procédures
À l’intérieur d’un même module, le code est structuré en procédures. Une procédure est une
séquence d’instructions s’exécutant en tant qu’entité. Cette décomposition rend le code plus per-
formant et plus lisible.
Par exemple, lorsqu’un projet VBA ouvre une boîte de dialogue (une feuille), pour chaque événe-
ment déclenché par l’utilisateur, l’application vérifie s’il existe une procédure (une unité de code)
affectée à cet événement dans le module correspondant. Si tel est le cas, la procédure est exécutée.
C’est l’ensemble des procédures d’un projet, avec leurs interactions, qui forme un programme
complet. Par exemple, l’événement clic de souris sur un bouton OK d’une boîte de dialogue peut
déclencher une procédure qui récupère et traite l’ensemble des informations contenues dans
cette boîte de dialogue (Cette case est-elle cochée ? Quel est le texte saisi dans cette zone de
texte ?, etc.). Cette procédure peut ensuite appeler (ou invoquer) une autre procédure stockée
dans le Module de code du projet et lui passer les informations ainsi traitées. On parle alors
de procédure appelante et de procédure appelée ; cette dernière effectuera les tâches pour
lesquelles elle a été écrite en exploitant les données fournies par la première. Les informations
transmises sont les arguments passés.
Développer dans Visual Basic Editor
Chapitre 5
117
Définition
On qualifie de procédure événementielle (ou d’événement) une procédure déclenchée par un événement
spécifique, tel qu’un clic de souris ou la frappe d’une touche clavier, par opposition aux procédures stan-
dards d’un module de code, indépendantes de toute interaction utilisateur.
Info
Dans les modules UserForm, les procédures sont prédéterminées ; il en existe une pour chaque événement
susceptible d’affecter un contrôle. Dans les modules de code, c’est vous qui déterminez les différentes
procédures. Vous pourriez notamment décider de n’en écrire qu’une seule contenant tout le programme.
Il est cependant conseillé de structurer le code en procédures distinctes. La lecture et le débogage de vos
programmes en seront considérablement améliorés.
Nous vous conseillons de structurer vos codes en petites procédures effectuant chacune un traite-
ment spécifique. Le programme principal consiste alors en une procédure qui appelle les autres.
Examinez le programme suivant :
Sub CalculPaieNette()
NomRepr = InputBox("Entrez le nom du représentant : ")
Call VerifierNomRepresentant(NomRepr)
SalaireRepr = QuelSalaire(NomRepr)
ChiffreRepr = InputBox("Entrez le chiffre d'affaires réalisé : ")
Prime = CalculPrime(ChiffreRepr)
MsgBox "La paie nette sera de " & CalculPaie(SalaireRepr, Prime)
End Sub
Cette procédure est composée de six instructions, dont quatre font appel à d’autres procédures
pour exécuter des tâches spécifiques. VerifierNomRepresentant est appelée afin de vérifier que le
nom indiqué est valide ; si ce n’est pas le cas, elle prendra en charge la résolution du problème
ou appellera une autre procédure conçue dans ce but. QuelSalaire et CalculPrime sont ensuite
appelées afin de renvoyer le salaire et la prime du représentant. Enfin, CalculPaie est appelée pour
renvoyer la paie du représentant, qui s’affiche dans une boîte de dialogue.
Les techniques d’appels de procédures sont traitées en détail plus loin dans ce chapitre.
Cette façon de procéder présente plusieurs avantages :
• Les programmes sont plus faciles à lire et, chaque procédure prenant en charge une tâche
spécifique, il est plus aisé d’en comprendre le fonctionnement ;
• En cas de bogue du programme, il est plus facile d’isoler la procédure coupable et de corriger
le problème ;
• Le code est ainsi réutilisable. Si une tâche a été isolée dans une petite procédure, elle peut être
exploitée par différents programmes ;
• Dans l’exemple précédent, VerifierNomRepresentant est appelée pour contrôler la validité du
nom entré par l’utilisateur. Cette procédure peut être appelée par d’autres programmes, sans
qu’il soit nécessaire de la réécrire.
Programmer en Visual Basic
118 Deuxième partie
Les instructions
Une procédure est composée d’instructions, chacune exécutant une tâche précise, qui peut être
évidente ou invisible pour l’utilisateur et destinée à effectuer des traitements propres au projet.
Une instruction Visual Basic est composée de mots-clés du langage, de constantes et de variables.
Ces éléments peuvent être combinés pour former une expression qui vérifie des données ou
effectue une tâche.
Par exemple, Mavar = Workbooks.Count est une instruction. Elle combine la variable Mavar et les
mots-clés =, Workbooks et Count. Pour affecter à la variable Mavar une valeur égale au nombre de
classeurs ouverts, on associe cette variable à l’expression Workbooks.Count à l’aide de l’opéra-
teur arithmétique = (la propriété Workbooks renvoie la collection d’objets Workbooks représentant
l’ensemble des classeurs ouverts et la propriété Count renvoie le nombre d’objets de la collection
spécifiée).
Définition
Un mot-clé est un mot ou un symbole reconnu comme élément du langage Visual Basic. Il peut s’agir d’une
fonction, d’une propriété, d’une méthode ou encore d’un opérateur arithmétique.
Rappel
Une constante est un élément nommé affecté à une valeur qui, contrairement à une variable, ne change
pas durant l’exécution du programme. Le nom de la constante est utilisé à la place de la valeur qui lui est
affectée. Un programme exploite des constantes propres à l’application ou définit ses propres valeurs à
l’aide de l’instruction Const (voir chapitre 6).
Vous pouvez par exemple définir une constante que vous nommerez TVA et à laquelle vous affecterez
la valeur 0,186. Chaque fois que vous aurez besoin de cette valeur dans votre programme, il vous suffira
d’utiliser le nom de la constante qui lui est affectée. Ainsi, l’expression :
PrixHorsTaxe * TVA
sera équivalente à :
PrixHorsTaxe * 0.186
Rappel
Les variables sont définies par un nom autre qu’un mot-clé du langage ; elles servent à stocker des infor-
mations modifiées au cours de l’exécution du programme.
Sub MaProcédure() est un exemple d’instruction de déclaration utilisée pour nommer la procé-
dure MaProcédure. Dim Mavar As String est aussi une instruction de déclaration. L’instruction
Dim sert à nommer la variable MaVar, tandis que As String en spécifie le type (une chaîne de
caractères).
• Les instructions d’affectation : elles affectent une valeur ou une expression à une variable, à une
constante ou encore à une propriété – et contiennent donc toujours l’opérateur =. L’exécution
de ce type d’instructions peut être visible comme invisible pour l’utilisateur.
MaVar = 5 et MaVar = Workbooks.Count sont des exemples d’instructions d’affectation, attribuant
respectivement une valeur et une expression à la variable MaVar.
Let est l’instruction d’affectation de Visual Basic. Ainsi l’instruction MaVar = 5 peut aussi être
écrite sous la forme Let MaVar = 5. Cependant, elle est facultative et généralement omise.
ActiveSheet.Range("C1").Font.Name = "Arial" est une instruction d’affectation visible pour
l’utilisateur puisqu’elle applique la police Arial à la cellule C1 de la feuille Excel active – la
valeur «Arial» est affectée à la propriété Name de l’objet Font de cette cellule.
• Les instructions exécutables : elles accomplissent des actions (exécution d’une méthode, d’une
fonction). Elles comprennent également les instructions de contrôle (traitées au chapitre 7).
MsgBox "Quel est le nombre de classeurs ouverts ?", vbOKOnly + vbInformation, "Bonne ques-
tion" est une instruction exécutable entraînant l’affichage de la boîte de dialogue représentée
à la figure 5-2. L’instruction MsgBox est étudiée au chapitre 7.
Cette procédure affiche une boîte de dialogue indiquant le nombre de classeurs ouverts dans la
session Excel active (voir figure 5-3).
Programmer en Visual Basic
120 Deuxième partie
Les deux premières instructions sont des déclarations nommant successivement la procédure
AfficherNbreClasseursOuverts et la variable NbreClasseurs. La valeur représentant le nombre de
documents ouverts est ensuite stockée dans la variable NbreClasseurs dans l’instruction d’affec-
tation de la ligne suivante. Enfin, l’instruction d’exécution MsgBox affiche une boîte de dialogue
indiquant à l’utilisateur le nombre de classeurs ouverts dans la session Excel. L’instruction de
déclaration End Sub signale la fin de la procédure.
Procédures Sub
Une procédure Sub (ou sous-routine) est une série d’instructions exécutant une tâche déterminée
au sein du projet, sans renvoyer de valeur. Elle est structurée de la façon suivante :
Sub NomDeLaProcédure()
Instructions
…
End Sub
Attention
Les noms de procédures, comme ceux des variables et des constantes, doivent obéir aux règles de Visual
Basic :
• contenir au maximum 255 caractères ;
• commencer par une lettre ;
• ne pas comprendre d’espace et ne pas utiliser les caractères @ & $ # . ! ;
• ne pas être identique à un mot-clé du langage, pour éviter tout conflit.
L’instruction de déclaration Sub peut aussi contenir des arguments optionnels, selon la syntaxe
suivante :
[Private|Public] [Static] Sub NomDeLaProcédure([Arguments])
Instructions
…
End Sub
Private ou Public indique si la procédure est privée ou publique. Une procédure publique peut
être invoquée n’importe où dans le projet, y compris dans d’autres modules. Une procédure pri-
vée ne peut être invoquée qu’à l’intérieur du même module. On parle de portée de la procédure.
Lorsque les mots-clés Private et Public sont omis dans la déclaration de la procédure, cette
dernière est publique.
L’option Static indique que les variables de la procédure Sub conservent leurs valeurs entre les
différents appels. Autrement dit, si une procédure Static est invoquée à plusieurs reprises lors de
l’exécution d’un programme, les variables qui lui sont propres ont la valeur qui leur a été affectée
lors de l’appel précédent.
Arguments représente les arguments (des valeurs séparées par des virgules) passés par la procédure
appelante.
Sub MaProcédure(arg1, arg2)
Dans cet exemple, MaProcédure est déclarée comme nécessitant les arguments arg1 et arg2.
Autrement dit, la procédure appelante devra lui transmettre ces arguments, ou bien une erreur
sera générée. Les appels de procédures et le passage d’arguments sont étudiés dans la section
« Appel et sortie d’une procédure », plus loin dans ce chapitre.
Chacun des arguments répond à la syntaxe suivante :
[Optional] [ByVal|ByRef] [ParamArray] NomVariable [As type] [=ValeurParDéfaut]
Programmer en Visual Basic
122 Deuxième partie
Élément Description
Optional Ce mot-clé indique que les arguments transmis sont facultatifs. Aucune erreur ne
sera générée si la procédure appelante ne les passe pas.
Si vous souhaitez déclarer des arguments facultatifs et d’autres obligatoires, vous
devez d’abord déclarer ceux qui sont obligatoires.
Dans l’instruction Sub MaProcédure(arg1, arg2, Optional arg3,
Optional arg4), les arguments arg1 et arg2 doivent obligatoirement être passés
par la procédure appelante, tandis que arg3 et arg4 sont facultatifs.
ByVal ou ByRef Ces mots-clés indiquent respectivement que l’argument est passé par valeur ou
par référence.
Lorsqu’un argument est passé par valeur, c’est le contenu de la variable, et non son
adresse, qui est transmis à la procédure appelée ; cette valeur est exploitée par la
procédure, mais ne peut être modifiée.
Lorsqu’un argument est passé par référence, c’est son adresse qui est transmise.
La procédure exploite alors la valeur de la variable, mais peut aussi la modifier.
Par défaut (lorsque ces mots-clés sont omis), le passage d’un argument se fait par
référence.
Dans l’exemple suivant :
Sub MaProcédure(ByVal MaVar)
MaVar = MaVar * 100
End Sub
la valeur de la variable passée MaVar est multipliée par 100 dans MaProcédure,
mais MaVar étant passée par valeur, son contenu réel ne sera pas modifié.
ParamArray Ce mot-clé indique que l’argument est un tableau Optional. L’argument déclaré
avec ce mot-clé doit être en dernière position dans la liste des arguments et ne
peut utiliser conjointement l’un des mots-clés précédemment décrits dans ce
tableau.
As Type Spécifie le type de l’argument passé à la procédure : Byte, Boolean, Integer,
Long, Currency, Single, Double, Date, String, Object, Variant, ou un type
défini par l’utilisateur. Une erreur est générée si la variable passée par la procédure
appelante est incompatible avec le type déclaré.
L’instruction de déclaration de MaProcédure suivante indique qu’un argument Arg1
de type String (chaîne de caractères) est requis :
Sub MaProcédure(Arg1 As String)
Les différents types de données ainsi que la création de types personnalisés sont
étudiés au chapitre 6.
= ValeurParDéfaut Indique une valeur par défaut pour l’argument. Ce paramètre ne peut être utilisé
que conjointement avec le mot-clé Optional. Il détermine une valeur par défaut,
qui sera employée si l’argument n’est pas passé par la procédure appelante.
Il peut s’agir d’une constante (numérique, booléenne ou de type chaîne de
caractères) ou d’une expression constante. Une expression renvoyant une valeur
variable ne peut être utilisée.
Dans l’exemple suivant, si l’argument Arg1 n’est pas passé par la procédure
appelante, sa valeur sera la chaîne "Bonjour".
Sub MaProcédure(Arg1 = "Bonjour")
Développer dans Visual Basic Editor
Chapitre 5
123
Attention
Si, dans la déclaration d’une procédure Sub, vous indiquez des arguments facultatifs à l’aide du mot-clé
Optional sans spécifier de valeur par défaut, la procédure devra être conçue pour s’exécuter sans faire
appel à ces arguments lorsqu’ils ne sont pas transmis. Dans le cas contraire, une erreur sera générée.
Static Sub ProcédureStatic(MaVar)
Dim MaVarStatique
MaVarStatique = MaVarStatique + MaVar
MsgBox MaVarStatique
End Sub
Définition
Une variable est dite locale lorsqu’elle est propre à une procédure, par opposition à une variable publique
ou passée par la procédure appelante.
Dim MaVar
Sub ProcédureAppelante()
MaVar = 2
Call ProcédureStatic(MaVar)
Call ProcédureStatic(MaVar)
Call ProcédureStatic(MaVar)
End Sub
Ce programme se comporte comme nous l’avons détaillé dans l’exemple précédent, mais
ProcédureStatic affecte en plus la valeur 100 à MaVar avant de redonner la main à la procédure
appelante. Néanmoins, le programme continue d’afficher trois boîtes de dialogue dont les messages
sont successivement 2, 4 et 6. En effet, l’instruction de déclaration de ProcédureStatic spécifie
que l’argument MaVar est appelé par valeur (ByVal) et non par adresse. La valeur de MaVar est donc
exploitée, mais ne peut être modifiée. MaVar retrouve donc sa valeur initiale dès que la procédure
appelante reprend la main.
Supprimez le mot-clé ByVal dans l’instruction de déclaration de ProcédureStatic. L’argument
MaVar est maintenant passé par adresse, et sa valeur peut donc être modifiée. Le programme
affiche maintenant trois boîtes de dialogue dont les messages sont successivement 2, 102 et 202.
Procédures Function
Une procédure Function (ou fonction) est une série d’instructions exécutant une tâche déterminée
au sein du projet et renvoyant une valeur ; cette procédure sera exploitée par d’autres procédures.
Elle est structurée de la façon suivante :
Function NomDeLaProcédure(Arguments)
Instructions
…
NomDeLaProcédure = Expression
…
End Function
L’instruction de déclaration Function peut aussi contenir des arguments facultatifs, selon la syn-
taxe suivante :
[Private|Public] [Static] Function NomDeLaProcédure ([Arguments]) [As Type]
Instructions
…
NomDeLaProcédure = Expression
End Function
As Type précise le type de valeur renvoyé par la procédure. Il peut s’agir de l’un de ceux présentés
au chapitre 6. S’il n’est pas précisé, la fonction renverra une valeur de type Variant. Comme nous
l’avons déjà mentionné, il est recommandé de préciser cet argument afin de limiter la mémoire
employée par le programme.
Les mots-clés Private et Public indiquent si la procédure est privée ou publique. Le mot-clé Static
indique que les variables locales de la procédure sont statiques, c’est-à-dire conservent leurs
valeurs entre les appels. Pour un rappel de ces concepts, reportez-vous à la section précédente,
« Procédures Sub ».
Arguments représente les arguments, séparés par des virgules, passés à Function par la procédure
appelante.
Sub MaFonction(arg1, arg2)
Dans cet exemple, MaFonction est déclarée comme nécessitant les arguments arg1 et arg2.
Autrement dit, la procédure appelante devra lui passer ces arguments, ou bien une erreur sera
générée. Les appels de procédures et le passage d’arguments sont étudiés dans la section « Appel
et sortie d’une procédure », plus loin dans ce chapitre.
Chacun des arguments répond à la syntaxe suivante :
[Optional] [ByVal|ByRef] [ParamArray] NomVariable [As type] [=ValeurParDéfaut]
Cette syntaxe est la même que pour les arguments d’une instruction Sub ; reportez-vous au
tableau 5-1.
La procédure suivante calcule la surface d’un cercle :
Function SurfaceCercle(Rayon As Long) As Long
Const Pi = 3.14
SurfaceCercle = Pi * Rayon * Rayon
End Function
La première ligne déclare la fonction en indiquant que l’argument Rayon est requis. La fonction
ainsi que l’argument attendu sont de type Long. Une constante Pi est ensuite définie. À la troisième
ligne, on affecte à la fonction une expression calculant la surface du cercle dont on a transmis le
rayon. Enfin, l’instruction End Function signale la fin de la procédure.
Les fonctions sont faciles à appeler à partir d’autres procédures. Vous pouvez les utiliser comme
n’importe quelle fonction intégrée de Visual Basic, c’est-à-dire en faisant apparaître dans une
expression son nom suivi de la liste des arguments requis entre parenthèses.
Programmer en Visual Basic
126 Deuxième partie
Function SurfaceCercle(Rayon)
Const Pi = 3.14
SurfaceCercle = Pi * Rayon * Rayon
End Function
La sous-routine MaProcédure déclare la variable Rayon et lui affecte la valeur 10. Elle affiche ensuite
une boîte de dialogue dont une partie du message fait appel à la fonction SurfaceCercle en lui
passant l’argument Rayon. Cette dernière calcule donc la surface du cercle et rend la main à la
procédure appelante, qui affiche la boîte de dialogue présentée à la figure 5-4.
Procédures Property
Une procédure Property (ou procédure de propriété) est une série d’instructions exécutant une
tâche déterminée au sein du projet et manipulant des données de type Propriétés. Il existe trois
types de procédures Property :
• Property Get. Elles renvoient la valeur d’une propriété qui sera ensuite exploitée par d’autres
procédures.
• Property Let. Ces procédures définissent la valeur d’une propriété.
• Property Set. Elles établissent une référence entre un objet et une propriété.
Rappel
Une propriété est un attribut nommé d’un objet, définissant ses caractéristiques ou son état. Par exemple,
la propriété Address d’un objet Range en renvoie l’adresse (A1, par exemple) et la propriété ColorIndex
d’un objet Font (une police de caractères) en renvoie la couleur.
Développer dans Visual Basic Editor
Chapitre 5
127
Procédures Property Get
Une procédure Property Get est structurée de la façon suivante :
Property Get NomDeLaProcédure()
Instructions
…
NomDeLaProcédure = Expression
…
End Property
Attention
Ce listing est numéroté de façon à simplifier la présentation des différentes instructions de la procédure
RenvoyerCommentaire. La présence de cette numérotation dans la procédure réelle générerait évidem-
ment une erreur à l’exécution.
À la ligne 1, l’instruction Property Get déclare la procédure RenvoyerCommentaire, qui doit recevoir
l’argument Cellule de type Range et qui renvoie une valeur de type String. Une instruction de
Programmer en Visual Basic
128 Deuxième partie
contrôle Select Case est utilisée des lignes 2 à 13 pour tester la valeur renvoyée par l’expression
Cellule.Value. Pour chacune des plages de valeurs testées, une chaîne de caractères est affectée
à la procédure de propriété.
Les procédures Property Get sont simples à appeler à partir d’autres procédures. Vous pouvez les
utiliser dans n’importe quelle expression exploitant une valeur de propriété, en faisant apparaître
le nom de la procédure suivi de la liste des éventuels arguments entre parenthèses.
Considérez les procédures suivantes :
Sub DefinirCommentaire()
Dim LaCellule As Range
For Each LaCellule In Selection
LaCellule.AddComment (RenvoyerCommentaire(LaCellule))
Next LaCellule
End Sub
où Expression renvoie un objet Range (une cellule ou une plage de cellules) et Texte est le
commentaire.
Plutôt qu’une chaîne de caractères, l’argument Texte reçoit ici pour valeur l’expression
RenvoyerCommentaire(LaCellule). Cette expression appelle la procédure Property Get du même
nom, en lui passant l’argument LaCellule. Cette procédure s’exécute et renvoie une chaîne de
caractères. Celle-ci est passée à la procédure appelante qui l’affecte, en tant que commentaire
de la cellule (voir figure 5-5).
Développer dans Visual Basic Editor
Chapitre 5
129
Procédures Property Let
Une procédure Property Let est structurée de la façon suivante :
Property Let NomDeLaProcédure (VarStockage)
Instructions
End Property
Syntaxe avancée
Au même titre que les instructions Sub et Function, les instructions de déclaration Property Get et
Property Let peuvent être précédées des mots-clés Private ou Public et/ou Static, afin de spécifier
si la procédure est privée ou publique et si ses variables locales sont statiques. Pour un rappel de
ces concepts, reportez-vous à la section « Procédures Sub » de ce chapitre.
Les instructions de déclaration Property Get et Property Let peuvent aussi spécifier des arguments
placés entre les parenthèses qui suivent le nom de la procédure. Chacun des arguments répond
à la syntaxe suivante :
[Optional] [ByVal|ByRef] [ParamArray] NomVariable [As type] [=ValeurParDéfaut]
Cette syntaxe est la même que pour les déclarations Sub et Function ; reportez-vous à la section
« Procédures Sub », plus haut dans ce chapitre.
Enfin, une instruction Property Get peut se terminer par l’argument As Type : c’est un moyen de
préciser le type de valeur renvoyé par la procédure.
Ajouter un module
Vous serez probablement amené à développer des applications VBA distinctes au sein d’un même
projet. Dans ce cas-là, il est important de regrouper leurs procédures dans des modules séparés.
Si vous les stockez toutes au sein d’un même module, sans aucune distinction, vous risquez d’être
rapidement dépassé par un nombre important de procédures dont vous serez incapable de définir
les rapports.
Pour créer un module standard ou un module de classe, procédez comme suit :
1. Lancez Visual Basic Editor à partir d’Excel (Alt+F11) – le document hôte du projet doit être
ouvert.
2. Affichez l’Explorateur de projet (Ctrl+R). Si plusieurs projets sont accessibles, cliquez sur
n’importe quel élément du projet auquel vous souhaitez ajouter un module, afin de l’activer.
Programmer en Visual Basic
132 Deuxième partie
3. Pour ajouter un module au projet actif et ouvrir sa fenêtre Code, choisissez l’une des trois
méthodes suivantes :
– Cliquez-droit et, dans le menu contextuel qui s’affiche, sélectionnez Insertion. Dans le sous-
menu, sélectionnez Module ou Module de classe.
– Ouvrez le menu Insertion et choisissez la commande Module ou Module de classe.
– Cliquez sur la flèche du bouton Ajouter… de la barre d’outils Standard. Dans le menu qui
s’affiche, sélectionnez Module ou Module de classe.
– Le module inséré est automatiquement nommé : Module1 (ou Module2 si Module1 existe
déjà…) pour un module standard et Class1 (Class2 si Class1 existe déjà…) pour un module
de classe.
4. Ouvrez la fenêtre Propriétés (F4) du nouveau module et donnez-lui un nom représentatif. Ce
dernier, qui apparaît dans la barre de titre de la fenêtre Code et dans l’Explorateur de projet,
est automatiquement mis à jour (voir figure 5-6).
Le nom du module est mis à jour dans l'Explorateur
de projet et dans la barre de titre de la fenêtre Code
Supprimer un module
Pour supprimer un module ou une feuille d’un projet, procédez comme suit :
1. Sélectionnez ce que vous voulez supprimer dans l’Explorateur de projet.
2. Cliquez-droit et, dans le menu contextuel qui s’affiche, sélectionnez Supprimer Module.
Visual Basic Editor affiche une boîte de dialogue vous proposant d’exporter le module avant
la suppression (voir figure 5-7).
Développer dans Visual Basic Editor
Chapitre 5
133
Info
Pour sauvegarder un module sans le supprimer, sélectionnez la commande Fichier > Exporter un fichier.
Vous pourrez ensuite l’importer dans n’importe quel projet en choisissant Fichier > Importer un fichier.
Programmer en Visual Basic
134 Deuxième partie
Attention
Les procédures ne peuvent être imbriquées. Veillez donc à ce que le point d’insertion se trouve à l’extérieur
de toute procédure.
Info
La commande Procédure n’est pas disponible si la fenêtre active n’est pas une fenêtre Code.
3. Entrez les informations décrivant la procédure : son nom, son type (bouton radio), sa portée ;
et cochez éventuellement la case Toutes les variables locales statiques.
4. Cliquez sur le bouton OK. La boîte de dialogue se ferme et les instructions d’encadrement de
la procédure sont insérées dans la partie inférieure de la fenêtre Code.
5. Saisissez les éventuels arguments entre les parenthèses.
6. Saisissez le code de votre procédure entre l’instruction de déclaration et l’instruction End
correspondante.
Programmer en Visual Basic
136 Deuxième partie
Info
Lorsque vous sélectionnez le type Property, les instructions d’encadrement d’une procédure Pro-
perty Get et d’une procédure Property Let sont insérées.
La notion de portée
La portée d’une procédure est essentielle, puisqu’elle en détermine l’accessibilité dans le reste
du projet. Publique, elle est visible pour n’importe quelle procédure du projet, quel que soit son
module de stockage ; privée, elle est invisible pour les procédures autres que celles de son module.
La portée d’une procédure est déterminée dans son instruction de déclaration, grâce au mot-clé
Public ou Private.
Par défaut, les procédures des modules de code et de classe sont publiques. Il n’est donc pas utile
de placer le mot-clé Public dans ce cas. En revanche, si vous souhaitez déclarer une procédure
privée, vous devez ajouter le mot-clé Private devant l’instruction de déclaration.
Une procédure événementielle est, par définition, privée. Elle ne peut en effet pas être appelée par
une autre procédure, puisque seul l’événement spécifié est capable de la déclencher. Comme vous
le verrez au chapitre 15, lorsque vous créez des procédures événementielles, le mot-clé Private
est automatiquement inséré.
Les deux instructions suivantes déclarent une procédure Sub de portée publique :
Sub MaProcédurePublique()
Instructions
End Sub
Public Sub MaProcédurePublique()
Instructions
End Sub
Développer dans Visual Basic Editor
Chapitre 5
137
Notez que le message affiché par la fonction MsgBox a été séparé en plusieurs chaînes de caractères
concaténées à l’aide de l’opérateur &. Le caractère de continuité de ligne ne peut en effet être utilisé
qu’entre des éléments distincts d’une instruction. Autrement dit, une même chaîne de caractères,
une expression, un mot-clé ou encore une constante ne peuvent être écrits sur plusieurs lignes.
Les commentaires
Un commentaire est une indication destinée à faciliter la lecture du code en décrivant les tâches
qu’exécute une instruction, la date de création d’une procédure, etc.
L’insertion de commentaires dans le texte d’une procédure est utile, particulièrement si elle com-
prend un grand nombre d’instructions dont vous souhaitez reconnaître rapidement les fonctions
respectives.
Si vous souhaitez insérer des commentaires dans le texte d’une procédure, il faut bien évidemment
que ceux-ci soient reconnus en tant que tels et non en tant qu’instructions, ce qui générerait une
erreur lors de l’exécution de la procédure.
Visual Basic considère le texte en tant que commentaire et l’ignore lors de l’exécution d’une
procédure s’il est précédé :
Programmer en Visual Basic
138 Deuxième partie
• d’une apostrophe ( ‘ ) ;
• du mot-clé REM.
Par défaut, les commentaires apparaissent en vert dans Visual Basic Editor. Pour en modifier la
couleur d’affichage, reportez-vous à la section « Un code tout en couleurs », plus loin dans ce
chapitre.
Utiliser l’apostrophe
L’utilisation de l’apostrophe pour marquer les commentaires permet de les placer à n’importe quel
endroit du texte. Vous pouvez ainsi insérer un commentaire sur la même ligne que l’instruction
concernée en plaçant autant d’espaces que vous le souhaitez entre celle-ci et l’apostrophe. Cette
façon de faire est particulièrement intéressante et efficace pour les instructions dont la syntaxe
est courte, puisqu’il est possible d’aligner les différents commentaires (figure 5-12).
Utiliser REM
La syntaxe REM joue le même rôle que l’apostrophe. Cependant, contrairement à celle-ci, le mar-
queur REM ne peut être accolé à l’instruction qu’il commente mais doit toujours être placé en début
de ligne. Il sera donc utilisé de préférence pour commenter des blocs d’instructions (figure 5-13).
Conseil
Utilisez des caractères facilement discernables pour faire ressortir les commentaires :
'*******************************
'****Ceci est un commentaire****
'*******************************
Info
Lorsque vous enregistrez une macro dans l’application hôte, des lignes de commentaires indiquant la date
d’enregistrement sont placées derrière l’instruction de déclaration de la procédure.
Figure 5-14 – Utilisez les retraits de ligne pour améliorer la lisibilité de votre code.
Programmer en Visual Basic
140 Deuxième partie
Définition
Des instructions sont dites imbriquées lorsque leur exécution s’effectue à l’intérieur d’un autre bloc d’ins-
tructions. Vous pouvez, par exemple, créer une instruction conditionnelle qui vérifie qu’une plage de cel-
lules contient des valeurs numériques et y imbriquer une autre structure conditionnelle qui effectuera des
tâches déterminées. Les structures de contrôle et leur imbrication sont étudiées au chapitre 7.
Les retraits de ligne sont indifféremment composés d’espaces ou de tabulations. L’éditeur peut
aussi être paramétré de façon que, lorsqu’un retrait est ajouté à une ligne, il soit appliqué aussi
à la ligne suivante :
1. Choisissez la commande Options du menu Outils et sélectionnez l’onglet Éditeur.
2. Cochez la case Retrait automatique, puis définissez une valeur comprise entre 1 et 32 dans la
zone Retrait de la tabulation. Cela correspond au nombre d’espaces qui seront appliqués lors
de la frappe de la touche Tabulation.
3. Cliquez sur OK pour valider les paramètres définis.
Pour augmenter ou diminuer simultanément le retrait de ligne de plusieurs instructions, sélec-
tionnez celles-ci, puis cliquez sur le bouton Retrait ou sur le bouton Retrait négatif de la barre
d’outils Édition.
Figure 5-15 – Les couleurs, retranscrites ici en niveaux de gris, déterminent les catégories de texte
et mettent en valeur les erreurs de syntaxe.
Développer dans Visual Basic Editor
Chapitre 5
141
Pour définir vos propres paramètres d’affichage du texte dans la fenêtre Code, procédez comme
suit :
1. Choisissez la commande Options du menu Outils, puis activez l’onglet Format de l’éditeur
(voir figure 5-16).
2. Dans la zone Couleur de code, sélectionnez la catégorie dont vous souhaitez modifier l’affi-
chage. Déterminez ensuite les options de votre choix dans les listes déroulantes suivantes :
– Premier plan. Définit la couleur de premier plan. Lorsque le texte n’est pas sélectionné,
il s’agit de la couleur des caractères.
– Arrière-plan. Détermine la couleur d’arrière-plan.
– Indicateurs. Définit la couleur des indicateurs apparaissant en marge, pour les catégories
du langage affichant ce type d’indicateur.
3. Modifiez éventuellement la police d’affichage du code dans la liste déroulante Police et dans
la zone Taille.
4. Pour masquer la barre des indicateurs en marge, décochez la case correspondante. Vous gagne-
rez de l’espace pour afficher le code.
5. Cliquez sur OK pour valider les paramètres d’affichage définis.
Conseil
Les paramètres d’affichage du code tels qu’ils sont définis par défaut dans Visual Basic Editor assurent
une lecture confortable à l’écran. Si vous souhaitez cependant les personnaliser, veillez à conserver cette
qualité de lecture.
Programmer en Visual Basic
142 Deuxième partie
Info
S’il est impossible d’effectuer un glisser-déplacer dans la fenêtre Code, sélectionnez Outils puis Options et
cochez la case Glisser-déplacer pour l’édition de texte de l’onglet Éditeur.
Conseil
N’oubliez pas que l’Enregistreur de macro peut réduire de façon considérable le travail d’écriture de code.
N’hésitez pas à enregistrer les tâches qui peuvent l’être ; ajoutez ensuite les autres instructions dans la
fenêtre Code de la macro.
Si vous devez ajouter des instructions à une macro, vous pouvez enregistrer les commandes correspon-
dantes dans une nouvelle macro, puis coller le code ainsi généré à l’emplacement voulu.
Pour appeler une procédure de type Sub, utilisez le mot-clé Call, selon la syntaxe suivante :
Call NomProcédure
Conseil
Une instruction contenant simplement le nom d’une procédure suffit à appeler cette dernière. L’omission du
mot-clé Call est cependant déconseillée, car le code y perd en lisibilité.
Sub Procédure2()
MsgBox "1er message de la procédure 2"
Call Procédure3
MsgBox "2e message de la procédure 2"
End Sub
Sub Procédure3()
MsgBox "1er message de la procédure 3"
MsgBox "2e message de la procédure 3"
End Sub
Attention
Pour appeler une procédure, celle-ci doit être visible pour la procédure appelante. Pour plus d’informa-
tions, reportez-vous à la section « La notion de portée », plus haut dans ce chapitre.
Passage d’arguments
Lorsqu’une procédure est appelée, il est souvent nécessaire de lui passer des valeurs. Elle les
exploite alors et peut à son tour passer des valeurs à une autre procédure. Les arguments admis
doivent apparaître entre parenthèses dans l’instruction de déclaration de la procédure appelée.
Ils sont facultatifs ou obligatoires, de type défini ou non.
L’argument passé peut être une valeur ou toute expression renvoyant une valeur d’un même type
de données – voir au chapitre 6.
Pour une revue détaillée de la syntaxe de déclaration des arguments d’une procédure, reportez-
vous au tableau 5-1.
où ValArg1, ValArg2 et ValArg3 sont respectivement les valeurs que prendront les arguments Arg1,
Arg2 et Arg3.
Développer dans Visual Basic Editor
Chapitre 5
145
Certains arguments sont optionnels ; la procédure appelée s’exécutera correctement sans qu’ils
lui soient passés. Pour ignorer un argument, placez deux virgules consécutives dans l’instruction
d’appel correspondant à l’emplacement de l’argument dans l’instruction de déclaration de la
procédure appelée. Par exemple, l’instruction utilisée pour passer les arguments Arg1 et Arg3 à la
procédure MaProcédure sera :
Call MaProcédure(ValArg1, , ValArg3)
Attention
N’oubliez pas de placer une virgule pour chaque argument non transmis. Un tel oubli engendrerait un déca-
lage dans le passage de valeur à la procédure appelée. L’instruction suivante :
Call MaProcédure(ValArg1, ValArg3)
passe respectivement les valeurs ValArg1 et ValArg3 aux arguments Arg1 et Arg2 de MaProcédure.
Conseil
Pour vérifier si des arguments facultatifs ont été omis lors de l’appel de la procédure, utilisez la fonction
IsMissing selon la syntaxe suivante :
IsMissing(NomArgument)
La valeur True est renvoyée si aucune valeur correspondant à l’argument n’a été passée à la procédure ;
False dans le cas contraire.
Attention
La fonction IsMissing fonctionne avec des valeurs de type Variant. Si vous testez un argument d’un
autre type, IsMissing renverra toujours False, qu’il ait été passé ou non.
Arguments nommés
Le passage d’arguments selon leur ordre d’apparition dans l’instruction de déclaration de la pro-
cédure appelée est parfois périlleux. En particulier, lorsque des arguments facultatifs sont omis,
une simple virgule oubliée dans l’instruction d’appel pouvant provoquer une erreur du programme
ou, pire, des résultats erronés dont il sera difficile de détecter la source.
L’utilisation des arguments nommés évite de tels problèmes, puisqu’elle implique de nommer
la valeur passée à la procédure afin d’éviter toute ambiguïté. Le nom des arguments nommés
est reconnu par le programme. Lorsque vous déclarez une procédure, les arguments qui lui sont
affectés deviennent des arguments nommés. Il est alors possible de leur affecter des valeurs, dans
l’ordre de votre choix, en mentionnant le nom de l’argument dans l’instruction d’appel, selon la
syntaxe suivante :
Call NomProcédure (ArgNommé:=valeur, AutreArgNommé:=valeur)
Programmer en Visual Basic
146 Deuxième partie
Dans l’exemple suivant, PassageArgumentsNommés appelle MaProcédure et lui transmet les arguments
nommés NomFichier et Propriétaire :
Sub PassageArgumentsNommés()
Call MaProcédure(Propriétaire:=ActiveWorkbook.BuiltinDocumentProperties(3), _
NomFichier:=ActiveWorkbook.Name)
End Sub
MaProcédure accepte les arguments NomFichier et Propriétaire, tous deux de type String (chaîne
de caractères). PassageArgumentsNommés lui passe ces arguments, sans tenir compte de leur
ordre d’apparition, mais en utilisant leurs noms. L’argument Propriétaire reçoit pour valeur la
chaîne renvoyée par l’expression ActiveWorkbook.BuiltinDocumentProperties(3). La propriété
BuiltinDocumentProperties renvoie une collection DocumentProperties qui représente toutes les
propriétés de document prédéfinies. L’index 3 permet de ne renvoyer que le troisième membre de
la collection, en l’occurrence le nom de l’auteur. NomFichier se voit affecter la chaîne retournée
par l’expression ActiveWorkbook.Name qui renvoie le nom du classeur actif. Ces arguments sont
exploités par la procédure appelée pour afficher la boîte de dialogue représentée à la figure 5-17.
Info
Les arguments nommés ne sont pas une spécificité des procédures. Pour la plupart, les fonctions inté-
grées de Visual Basic les intègrent aussi.
Dans l’exemple suivant, une boîte de dialogue s’affiche à l’aide de la fonction MsgBox et demande
à l’utilisateur s’il souhaite exécuter de nouveau le programme.
Sub MonProgramme()
Instructions
Call AutreProcédure
Instructions
Recommencer = MsgBox ("Recommencer l'opération ?", vbYesNo + vbQuestion)
If Recommencer=vbYes Then
Call MonProgramme
Else
Exit Sub
End If
End Sub
MonProgramme exécute des instructions, puis appelle une autre procédure. Elle reprend ensuite la
main et exécute une autre série d’instructions. Une boîte de dialogue s’affiche, proposant à l’uti-
lisateur de réitérer l’opération. Une structure de contrôle If…End If est utilisée pour déterminer le
comportement du programme, en fonction de la réponse de l’utilisateur. S’il choisit le bouton Oui,
la procédure s’appelle elle-même et s’exécute de nouveau ; s’il choisit Non, une instruction Exit
entraîne la sortie de la procédure et le programme se termine.
Info
Les structures de contrôle et les fonctions MsgBox et InputBox sont étudiées au chapitre 7.
Exécuter du code
À partir de Visual Basic Editor, placez le curseur dans la procédure que vous souhaitez exécuter,
puis cliquez sur le bouton Exécuter de la barre d’outils Standard, ou choisissez la commande
Exécuter Sub/UserForm du menu Exécution, ou appuyez sur la touche F5.
Seule une procédure Sub ne nécessitant pas d’arguments est accessible par la boîte de dialogue
Macro d’Excel. Pour l’exécuter à partir de l’application hôte, choisissez Outils > Macro > Macros,
sélectionnez la procédure dans la boîte de dialogue, puis cliquez sur le bouton Exécuter.
Définition
Macro or not macro ? Les macros sont des procédures Sub exécutables de façon autonome, donc sans
arguments. Une procédure qui attend des arguments ne peut qu’être appelée par une autre et n’apparaît
pas dans la liste des macros.
Vous pouvez aussi affecter un bouton de barre d’outils ou un menu de commande à une pro-
cédure Sub. L’activation de ce bouton ou de ce menu exécute alors la procédure. Pour plus de
précisions, reportez-vous au chapitre 12.
Info
Si l’exécution d’un programme retourne une erreur, reportez-vous au chapitre 11.
Figure 5-18 – Visual Basic Editor propose des outils d’aide à l’écriture de code.
Figure 5-19 – Vous êtes prévenu chaque fois qu’une erreur est détectée.
L’instruction invalide est ici encadrée en gris.
Astuce
Les options d’aide à l’écriture de code dans Visual Basic Editor peuvent aussi être activées via la barre
d’outils Édition.
6
Variables et constantes
Les variables sont un élément essentiel de la programmation. Elles servent à stocker les informations
de votre choix à tout moment de l’exécution d’un programme, pour les réexploiter à n’importe quel
autre moment. Vous pouvez, par exemple, stocker le nombre de classeurs ouverts, le nom du fichier, la
valeur ou l’adresse d’une cellule, les informations entrées par l’utilisateur dans une feuille VBA, etc.
Déclaration implicite
Si la déclaration explicite des variables n’est pas requise, le simple fait de faire apparaître un mot
non reconnu par le programme dans une instruction d’affectation suffira pour que ce nom soit
considéré comme une variable de type Variant – les types de variables sont présentés plus loin
dans ce chapitre. C’est le cas dans l’exemple suivant :
Sub DéclarImpliciteDeVariables()
MaVar = Range("D7").Value
MsgBox "La somme totale des transactions est " & MaVar, _
vbInformation + vbOKOnly
Instructions
End Sub
Programmer en Visual Basic
152 Deuxième partie
Le mot MaVar apparaît pour la première fois dans une instruction d’affectation valide. La variable
MaVar est donc créée et reçoit la valeur de la cellule D7. Elle est ensuite utilisée pour afficher un
message à l’attention de l’utilisateur (voir figure 6-1). L’opérateur de concaténation & sert à faire
apparaître la valeur de la variable au cœur d’une chaîne de caractères définie.
Figure 6-1 – Les variables peuvent être utilisées dans des chaînes à l’aide de l’opérateur de concaténation.
Vous pouvez attribuer le nom de votre choix à une variable, à condition qu’il respecte les règles
suivantes :
• il doit commencer par une lettre ;
• il ne peut contenir plus de 255 caractères ;
• le point, le point d’exclamation, les espaces et les caractères @, &, $ et # ne sont pas autorisés ;
• ce nom ne doit pas être un mot réservé, c’est-à-dire un mot reconnu comme un élément du
langage Visual Basic (nom de fonction, d’objet, de propriété, d’argument nommé, etc.).
Déclaration explicite
Il est fortement recommandé de déclarer explicitement les variables avant de les utiliser.
Cette procédure a pour but d’ouvrir dix classeurs en boucle. Le nombre de classeurs ouverts
(Workbooks.Count) est affecté à la variable MaVariable. Une instruction While…Wend – que vous
découvrirez dans le prochain chapitre – est utilisée pour créer un nouveau classeur (Workbooks.
Add) et ajouter 1 à MaVariable tant que la valeur de celle-ci est inférieure à 10. Cependant, le nom
de la variable a été incorrectement saisi dans la condition. MaVarable n’existant pas, elle est créée,
Variables et constantes
Chapitre 6
153
mais aucune valeur ne lui est affectée. La procédure ouvre donc des documents et incrémente
MaVariable de 1 à l’infini, sans que la condition MaVarable<10 ne soit jamais respectée.
Info
Pour interrompre une macro s’exécutant à l’infini, tapez la combinaison clavier Ctrl+Pause.
Pour éviter ce type d’erreur, forcez la déclaration explicite des variables. Pour cela, placez-
vous dans la section Déclarations de la fenêtre Code du module et saisissez-y l’instruction
Option Explicit (voir figure 6-2).
Figure 6-2 – L’instruction Option Explicit doit se trouver dans la section Déclarations de la fenêtre Code.
Vous pouvez aussi paramétrer Visual Basic Editor pour que l’instruction Option Explicit soit
systématiquement placée dans la section de Déclarations de tout nouveau module.
1. Sélectionnez la commande Options du menu Outils et placez-vous sur l’onglet Éditeur.
2. Cochez la case Déclaration explicite des variables, puis cliquez sur OK.
L’argument Type est facultatif, mais la déclaration d’un type de variable fait souvent économiser
de l’espace mémoire et améliore ainsi les performances de votre programme. Lors de la décla-
ration, une variable de type String prend pour valeur une chaîne vide, une variable numérique
prend la valeur 0.
Dans l’exemple suivant, les variables Message, Boutons et Titre sont déclarées à l’aide de l’instruc-
tion Dim, des valeurs leur sont ensuite affectées, puis sont utilisées comme arguments de MsgBox
afin d’afficher la boîte de dialogue de la figure 6-4.
Sub UtiliserDim()
Dim Message As String
Dim Boutons As Single
Dim Titre As String
Message = "La procédure est terminée."
Boutons = vbOKOnly + vbInformation
Titre = "C'est fini"
MsgBox Message, Boutons, Titre
End Sub
Figure 6-4 – Des variables peuvent être utilisées comme arguments d’une fonction.
Il est possible de déclarer plusieurs variables dans une même instruction Dim, selon la syntaxe
suivante :
Dim NomVar1 As Type, NomVar2 As Type, …, NomVarn As Type
Les trois instructions de déclaration de l’exemple précédent peuvent ainsi être ramenées à une
seule :
Dim Message As String, Boutons As Single, Titre As String
Variables et constantes
Chapitre 6
155
Gardez à l’esprit que pour affecter un type aux variables d’une telle instruction, celui-ci doit
être mentionné pour chacune des variables déclarées. L’instruction suivante déclare une variable
Message de type Variant et une variable Titre de type String :
Chaînes de caractères
Les variables de type String – encore appelées « variables de chaîne » – stockent toute expression
renvoyant une valeur de type chaîne (chaîne, propriété, fonction, etc.). Utilisez la syntaxe suivante :
Dim NomVariable As String
Une chaîne doit être placée entre guillemets. Si vous souhaitez insérer des guillemets dans une
chaîne (ou tout autre caractère), utilisez conjointement l’opérateur de concaténation & et la fonc-
tion Chr selon la syntaxe suivante :
"Chaîne de car." & Chr(codeANSI) & "Chaîne de car."
Info
L’opérateur + peut aussi être utilisé. Préférez cependant l’opérateur & pour concaténer des chaînes, afin de
les distinguer des additions de valeurs numériques qui, elles, requièrent l’opérateur +.
Figure 6-5 – Le message affiché par la fonction MsgBox est toujours une chaîne de caractères.
Les variables de chaîne définies précédemment sont dites de longueur variable et acceptent
jusqu’à environ deux milliards de caractères. Vous pouvez cependant déclarer des variables de
chaîne de longueur fixe, autorisant de 1 à 65 400 caractères, selon la syntaxe suivante :
Dim NomVariable As String * longueur
Les variables de longueur fixe économisent la mémoire utilisée par un programme – et donc en
améliorent les performances –, mais elles doivent être utilisée prudemment. En effet, si la chaîne
affectée à une variable de longueur fixe dépasse la capacité de cette dernière, elle sera purement
et simplement rognée. Remplacez la déclaration de l’exemple précédent par celle-ci :
Dim Message As String*15, Boutons As Single, Titre As String*5
Valeurs numériques
Les variables numériques stockent des valeurs sur lesquelles vous pouvez effectuer des opérations
arithmétiques. Il existe plusieurs types de variables numériques (tableau 6-1). Elles se distinguent
par l’échelle des valeurs qu’elles acceptent et par la place qu’elles occupent en mémoire.
Attention
Utilisez le point comme séparateur décimal dans le code VBA. L’utilisation de la virgule génère une erreur.
Programmer en Visual Basic
158 Deuxième partie
Une variable numérique peut être concaténée avec une chaîne de caractères à l’aide de l’opé-
rateur &. Il est aussi possible de l’affecter à toute expression renvoyant une valeur numérique
(chaîne, propriété, fonction, etc.) et d’effectuer des opérations à l’aide des opérateurs arithmétiques
présentés dans le tableau 6-2.
Opérateur Description
+ Addition
– Soustraction
* Multiplication
/ Division
\ Division. Seule la partie entière du résultat est renvoyée (l’opération 18\5 retournera la valeur 3).
^ Élévation à la puissance (2^4 renvoie 16).
À condition que le type de la variable numérique couvre les valeurs qui lui sont affectées, les
instructions suivantes sont toutes valides :
• MaValeur = 58
• NbreClasseur = Workbooks.Count
• Range("D5").Value = (Range("D3").Value + Range("D4").Value) / 2
• SurfaceCercle = (varRayon^2) * 3.14
La première instruction affecte une valeur définie à la variable MaValeur. La deuxième affecte la
valeur de la propriété Count de l’objet (la collection) Workbooks (le nombre de classeurs ouverts).
La troisième utilise l’opérateur + pour additionner les valeurs des cellules D3 et D4, puis l’opéra-
teur / pour diviser la valeur obtenue par deux. La dernière instruction élève au carré la variable
varRayon à l’aide de l’opérateur ^, puis multiplie le résultat par 3,14 à l’aide de l’opérateur *.
En revanche, l’instruction suivante affecte une valeur de type chaîne à la variable numérique
MaVar et génère une erreur (voir figure 6-8).
Sub ErreurAffectation()
Dim MaVar As Byte
MaVar = ActiveWorkbook.Name
End Sub
Figure 6-8 – Une chaîne de caractères ne peut être affectée à une variable numérique.
Variables et constantes
Chapitre 6
159
Rappelez-vous que les constantes sont en réalité des valeurs numériques. Une constante peut
donc être affectée à une variable numérique et entrer dans une expression arithmétique. Veillez
à ne pas utiliser l’opérateur &, réservé à la concaténation de chaînes. Par exemple, l’instruction :
MsgBox "Le message de la bdg", vbOKOnly + vbInformation, "Titre"
générera un message d’erreur, car l’opérateur & est utilisé pour additionner les valeurs affectées
aux constantes vbOKOnly et vbInformation.
VBA intègre de nombreuses fonctions pour manipuler les valeurs numériques. Par exemple,
ABS(nombre) renvoie la valeur absolue du nombre spécifié entre parenthèses et Int(nombre) renvoie
la partie entière.
La liste des fonctions VBA est consultable dans l’aide en ligne. Choisissez la rubrique Référence
du langage Visual Basic. Vous y trouverez une rubrique Fonctions répertoriant les fonctions par
ordre alphabétique. Vous pouvez également y choisir la rubrique Liste et index. Vous y décou-
vrirez des rubriques thématiques, telles que Résumé des mots-clés financiers, ou Résumé des
mots-clés mathématiques.
Valeurs booléennes
Une variable de type Boolean sert à stocker le résultat d’une expression logique. Elle renvoie la valeur
True ou False et occupe deux octets en mémoire. Elle peut aussi se voir affecter une valeur numé-
rique : si cette dernière est égale à zéro, la variable prendra la valeur False, la valeur True dans le cas
contraire. Une variable booléenne utilisée comme chaîne de caractères renvoie le mot Vrai ou Faux.
Dans l’exemple suivant, ClasseurSauvegardé prend la valeur False si le classeur actif a subi des
modifications depuis le dernier enregistrement ; True dans le cas contraire. Une boîte de dialogue
affiche ensuite le message Vrai ou Faux, en fonction de la valeur de ClasseurSauvegardé.
Sub ClasseurSauvegardéOuNon()
Dim ClasseurSauvegardé As Boolean
ClasseurSauvegardé = ActiveWorkbook.Saved
MsgBox ClasseurSauvegardé
End Sub
Dates
Les dates comprises entre le 1er janvier 100 et le 31 décembre 9999 peuvent être affectées à des
variables de type Date. Ces dernières sont stockées sous forme de nombres à virgule flottante et
occupent huit octets en mémoire.
La partie entière du nombre représente le jour. 0 correspond au 30 décembre 1899, 1 au
31 décembre 1899, etc. Les valeurs négatives représentent des dates antérieures au 30 décembre 1899.
La partie décimale du nombre représente l’heure. 0.5 correspond à 12 heures, 0.75 à 18 heures, etc.
Ainsi, 36526.00001 correspond au 1er janvier 2000, à 00:00:01.
Programmer en Visual Basic
160 Deuxième partie
Visual Basic intègre des fonctions pour manipuler les dates. Par exemple, Date, Time et Now ren-
voient respectivement la date courante, l’heure courante et la date courante suivie de l’heure
courante. La procédure suivante affiche la boîte de dialogue de la figure 6-9 :
Sub DateEtHeure()
Dim LaDate As Date, LHeure As Date
LaDate = Date
LHeure = Time
MsgBox "Nous sommes le " & LaDate & ", il est " & LHeure & ".", _
vbOKOnly + vbInformation, "Fonctions Date et Time"
End Sub
Figure 6-9 – Visual Basic intègre des fonctions pour manipuler les dates et les heures.
Pour plus d’informations sur les fonctions de date et d’heure, reportez-vous à l’aide Visual Basic,
en choisissant Résumé des mots-clés de date et d’heure de la rubrique Index/Listes du Manuel
de référence du langage. Vous pouvez également vous reporter au Manuel de référence pour
Microsoft Excel, disponible dans le sommaire de l’aide.
Attention
L’installation par défaut d’Excel n’installe pas l’aide en ligne de VBA. Vous devrez lancer de nouveau l’ins-
tallation en l’incluant.
Type Variant
Une variable de type Variant accepte des valeurs de tout type et peut être automatiquement convertie
d’un type à l’autre, tant que sa valeur est compatible. Autrement dit, une variable de type Variant peut
être initialement une chaîne de caractères, qui sera exploitée par la suite en tant que valeur numé-
rique. Si les données qui lui sont affectées sont assimilables à une valeur numérique, la conversion
se fera automatiquement, lorsque l’instruction assimilable à une opération numérique sera exécutée.
Si les variables de type Variant sont très pratiques, elles occupent un espace en mémoire plus
important que les autres types et peuvent donc ralentir l’exécution du programme.
Une variable, une constante ou un argument dont le type n’est pas déclaré est par défaut de type
Variant.
Variables et constantes
Chapitre 6
161
Variables de matrice
Une variable de matrice ou de type Array, encore appelée tableau, est capable de stocker plusieurs
valeurs de même type, contrairement à une variable ordinaire ne pouvant recevoir qu’une seule
valeur. Vous pouvez par exemple y stocker les chiffres d’affaires de tous les représentants. Pour
déclarer une variable de matrice, utilisez la syntaxe suivante :
Dim NomVariable(NbreElements) As Type
Pour affecter des valeurs à une variable de matrice ou accéder à ces dernières, il suffit de spécifier
la position de la valeur stockée dans la variable. La première valeur recevant l’index 0, la dernière
valeur est toujours égale au nombre d’éléments contenus dans la variable moins 1.
Astuce
Pour démarrer l’index d’un tableau à 1 plutôt qu’à 0, placez l’instruction Option Base 1 dans la section
Déclarations du module.
Une variable de matrice peut également être déclarée selon la syntaxe suivante :
Dim NomVariable(Début To Fin) As Type
où Début et Fin définissent la plage de valeurs qui sera utilisée pour stocker et accéder aux don-
nées de la variable.
Si une variable de matrice sert à stocker des données de même type, il est alors recommandé de
déclarer un type approprié. Dans l’exemple suivant, JoursSemaine stocke sous forme de chaînes
les jours de la semaine. Une structure de contrôle For…Next est ensuite utilisée pour afficher dans
une boîte de dialogue les valeurs contenues par la variable.
Sub VarMatrice()
Dim JoursSemaine(7) As String
JoursSemaine(0) = "Lundi"
JoursSemaine(1) = "Mardi"
JoursSemaine(2) = "Mercredi"
JoursSemaine(3) = "Jeudi"
JoursSemaine(4) = "Vendredi"
JoursSemaine(5) = "Samedi"
JoursSemaine(6) = "Dimanche"
Dim compteur as Byte
For compteur = 0 To 6
MsgBox JoursSemaine(compteur)
Next compteur
End Sub
Programmer en Visual Basic
162 Deuxième partie
Une variable de matrice peut aussi stocker des données de types différents. Elle doit alors être de
type Variant. La procédure suivante stocke dans une seule variable le nom, la date de naissance,
l’adresse, la fonction et le salaire d’un employé. Ces données sont ensuite affichées dans une boîte
de dialogue (voir figure 6-10).
Sub InfosEmployé
Dim Employé(1 To 5) As Variant
Employé(1) = "Jean Dupont"
Employé(2) = "25/12/71"
Employé(3) = "14, rue des Arts"
Employé(4) = "Chargé d'études"
Employé(5) = 2000
MsgBox Employé(1) & " est né le " & Employé(2) & ". Il habite " & _
Employé(3) & " et est " & Employé(4) & ". Son salaire est de : " & _
Employé(5) & " euros", vbOKOnly + vbInformation, "Infos employé"
End Sub
Astuce
Utilisez la fonction IsArray pour vérifier si une variable est de type Array.
Figure 6-10 – Toutes les informations relatives à un même sujet peuvent être stockées
dans une seule variable de matrice.
Considérez la feuille de classeur représentée à la figure 6-11. Elle représente les ventes mensuelles,
pour l’année 2003, de quatre types de produits – soit 12 lignes sur quatre colonnes. Une variable
de matrice multidimensionnelle stockera l’ensemble de ces valeurs :
Dim MonTableau(1 To 12, 1 To 4) As Single
Variables et constantes
Chapitre 6
163
Figure 6-11 – Utilisez une variable de matrice multidimensionnelle pour stocker les valeurs d’un tableau.
Il suffit ensuite d’affecter logiquement les valeurs de la feuille aux espaces de stockage de la
variable :
MonTableau(1,1) = Cells(2,2).Value
MonTableau(1,2) = Cells(2,3).Value
MonTableau(1,3) = Cells(2,4).Value
MonTableau(1,4) = Cells(2,5).Value
MonTableau(2,1) = Cells(3,2).Value
MonTableau(2,2) = Cells(3,3).Value
MonTableau(2,3) = Cells(3,4).Value
MonTableau(2,4) = Cells(3,5).Value
Etc.
Ainsi, pour accéder aux ventes d’un mois, il suffira de spécifier la valeur correspondante comme
premier index de la variable MonTableau (1 = janvier, 2 = février, etc.). De manière similaire, la
catégorie de ventes correspond à une valeur du second index (1 = Livres, 2 = Vidéo, 3 = Hi-Fi,
4 = Autres). Par exemple, MonTableau(1,1) renverra les ventes de janvier pour les livres et
MonTableau(12,2) renverra les ventes de décembre pour la vidéo.
N’hésitez pas à utiliser les variables de matrice pour stocker les données d’une feuille Excel
auxquelles un programme VBA doit accéder à de multiples reprises. La variable ainsi créée est
chargée en mémoire. L’accès aux données qu’elle contient est nettement plus rapide qu’un accès
aux valeurs contenues dans les cellules d’une feuille de calcul.
L’utilisation d’une structure de contrôle For…Next servira à affecter l’ensemble des valeurs à une
variable de matrice en quelques lignes de code. Vous apprendrez à utiliser cette structure au
chapitre 7.
Info
Une variable de matrice n’est pas limitée à deux dimensions. Vous pouvez parfaitement en créer une à trois
dimensions, ou plus.
Programmer en Visual Basic
164 Deuxième partie
Conseil
La fonction LBound (resp. UBound) renvoie le plus petit (resp. le plus grand) indice disponible pour une
dimension spécifiée d’un tableau :
LBound(NomVariable, Dimension) et UBound(NomVariable, Dimension)
Si l’argument Dimension est omis, le plus petit ou le plus grand indice de la première dimension est
renvoyé.
Avant d’affecter des valeurs à la variable ainsi créée, vous devrez la redimensionner à l’aide de
l’instruction ReDim, selon la syntaxe suivante :
ReDim NomVariable(Début To Fin)
Vous pouvez utiliser le mot-clé ReDim pour redimensionner une variable de matrice autant de fois
que vous le souhaitez. Ces variables sont intéressantes lorsque vous ne connaissez pas a priori
la quantité de données à stocker. Supposez que, dans l’exemple précédent, la feuille de calcul
des ventes ne soit pas annuelle, mais mensuelle. Le tableau s’enrichirait alors tous les mois d’une
nouvelle ligne. Pour que votre programme fonctionne tout au long de l’année, vous devrez créer
une variable de matrice de longueur variable :
1: Sub AffectationVariableArray()
2: Dim MonTableau() As Single
3: Dim DerniereLigne As Byte
4: DerniereLigne = Range("A2").End(xlDown).Row
5: Dim NbreDeLignes As Byte
6: NbreDeLignes = DerniereLigne - 1
7: ReDim MonTableau(NbreDeLignes,4)
8: Instructions d'affectation de valeurs à MonTableau
9: End Sub
Aux lignes 2 et 3, les variables MonTableau et DerniereLigne sont déclarées. L’instruction de la
ligne 4 sert à affecter à DerniereLigne le numéro de la dernière ligne contenant des données. La
fonction End renvoie l’objet Range correspondant à la dernière cellule non vide sous (xlDown) la
cellule A2. La propriété Row renvoie le numéro de ligne de cet objet. La variable NbreDeLignes
est créée ligne 5. On lui affecte ensuite une valeur égale à DerniereLigne - 1, soit le nombre de
lignes contenant des données à stocker dans la variable (la première ligne ne contenant que des
intitulés de colonnes). À la ligne 7, MonTableau est redimensionnée de façon à accueillir l’ensemble
des chiffres de ventes de la feuille.
Variables et constantes
Chapitre 6
165
Attention
Lorsque vous redimensionnez une variable de matrice, celle-ci est réinitialisée et toutes les valeurs qui y
étaient stockées sont perdues. Pour les conserver, placez le mot-clé Preserve devant l’instruction ReDim.
L’utilisation de ce mot-clé est cependant subordonnée à certaines conditions :
• Vous ne pouvez redimensionner que la dernière dimension de la variable.
• Vous ne pouvez pas modifier le nombre de dimensions du tableau.
• Vous ne pouvez qu’agrandir le tableau. Si vous le réduisez, toutes les données seront perdues.
La fonction première du tableur étant d’effectuer des calculs sur des données affichées sous forme
de tableaux, les variables de matrice sont très utilisées dans les programmes VBA pour Excel.
En effet, en stockant les données de feuilles de calcul sous forme de variables, vous améliorez
sensiblement les performances du programme.
Variables objets
Ces variables sont utilisées pour faire référence à un objet et occupent 4 octets en mémoire.
Une fois une variable objet définie, vous pouvez en chercher ou définir les propriétés, ou encore
exécuter l’une de ses méthodes en faisant simplement référence à la variable. Utilisez la syntaxe
suivante :
Dim NomVariable As Object
Il est mieux de remplacer Object par un nom d’objet reconnu par l’application. Vous pouvez, par
exemple, déclarer une variable objet Workbook (classeur) selon la syntaxe suivante :
Dim MonObjetClasseur As Workbook
Une fois la variable déclarée, vous devez lui affecter un objet précis ; utilisez pour cela le mot-
clé Set, selon la syntaxe suivante :
Set NomVariable = Expression
où Expression renvoie un objet de l’application. Dans l’exemple suivant, la variable Police est
déclarée en tant qu’objet Font, puis se voit affecter l’expression Workbooks("Representant.xlsx").
Sheets("Feuil1").Range("A1:D5").Font, soit l’objet Font (police) de la plage de cellules A1:D5
de la feuille libellée Feuil1 du classeur Representant.xlsx. La variable est ensuite utilisée pour
définir la propriété Bold de l’objet à True, c’est-à-dire pour affecter l’attribut gras à la plage de
cellules A1:D5 de ce classeur.
Sub VariablesObjet()
Dim Police As Font
Set Police = _
Workbooks("Representant.xlsx").Sheets("Feuil1").Range("A1:D5").Font
Police.Bold = True
End Sub
Programmer en Visual Basic
166 Deuxième partie
La fonction GetObject
Ce type de variable vous permet d’agir sur un objet sans que celui-ci soit ouvert. Ainsi, il est
possible de chercher ou modifier les valeurs d’une feuille Excel sans que le fichier ne soit ouvert.
Pour accéder à un objet, stockez-le dans une variable et utilisez la fonction GetObject, selon la
syntaxe suivante :
Set MonObjet = GetObject(pathname, class)
où pathname et class sont des arguments nommés de type chaîne, correspondant respectivement au
chemin d’accès complet au fichier et à la classe de l’objet. Si pathname est spécifié, class peut être omis.
La procédure suivante crée une variable objet de type Workbook et lui affecte le fichier Representant.
xlsx, situé sur le Bureau de Windows.
Sub AccederObjetFerme()
Dim ObjetClasseur As Workbook
Set ObjetClasseur = _
GetObject("C:\Users\Nom_utilisateur\Desktop\Representant.xlsx")
End Sub
La fonction GetObject est particulièrement intéressante si des données entrées dans un classeur
doivent être répercutées dans un ou plusieurs autres. Vous pouvez par exemple créer un programme
VBA afin que, lorsqu’un client vous passe une commande, le classeur contenant les données du
stock soit mis à jour. Si nécessaire, un message s’affichera pour prévenir l’utilisateur qu’il est
temps de renouveler le stock, sans même qu’il sache qu’il existe un classeur des stocks. C’est ce
que fait la procédure suivante, en supposant que la valeur du stock pour le produit commandé se
trouve dans la cellule A13 du classeur stock.xlsx.
1: Sub Commande()
2: 'Instructions
3: Dim StockRestant As Integer
4: Dim UnitésCommandées As Integer
5: UnitésCommandées = 50
6: StockRestant = VerifierEtMettreAJourStock(UnitésCommandées)
7: If StockRestant<0 Then
8: MsgBox "Le stock ne permet pas d'assurer la commande. " & _
"Le stock pour ce produit est de " & _
(StockRestant + UnitésCommandées) & " unités."
9: Exit Sub
10: Else
11: MsgBox "Commande effectuée. Le stock restant pour ce " & _
"produit est de " & StockRestant & " unités."
12: End If
13: 'Suite des instructions de la commande
14: End Sub
Attention
Veillez à personnaliser le chemin précisé pour la fonction GetObject à la ligne 18, sinon cette macro ne
fonctionnera pas.
La fonction CreateObject
La fonction CreateObject sert à créer une instance d’objet et s’utilise selon la syntaxe suivante :
CreateObject(class,servername)
où class (classe de l’objet dont on crée une instance) et servername (facultatif, nom d’un serveur
distant sur lequel est créé l’objet) sont des arguments nommés de type chaîne. Quand l’instance
est créée, on accède à ses propriétés et méthodes en utilisant le nom de la variable.
Dans l’exemple suivant, une instance de l’objet Excel est créée. Un nouveau classeur est alors
créé, configuré puis enregistré dans cette instance.
Programmer en Visual Basic
168 Deuxième partie
1: Sub CreerInstancesExcel()
2: 'déclaration des variables
3: Dim Xl As Excel.Application
4: Dim NouvClasseur As Excel.Workbook
5: Dim NomFichier As String
6: 'création d'une instance de l'objet Excel
7: Set Xl = CreateObject("Excel.Application")
8: 'affichage de l'objet Xl
9: Xl.Application.Visible = True
10: 'création d'un nouveau classeur dans l'objet Xl
11: Set NouvClasseur = Xl.Workbooks.Add
12: 'ajout d'une feuille de calcul
13: NouvClasseur.Sheets.Add
14: 'affectation de noms aux feuilles 1 et 2
15: NouvClasseur.Sheets(1).Name = "Quantites"
16: NouvClasseur.Sheets(2).Name = "Chiffres"
17: 'définition du nom du classeur
18: Dim compteur As Byte
19: Dim Pos As Long
20: NomFichier = "Ventes " & Date & ".xlsx"
21: For compteur = 1 To 2
22: Pos = InStr(NomFichier, "/")
23: NomFichier = Left(NomFichier, Pos - 1) & "-" & _
24: Right(NomFichier, Len(NomFichier) - Pos)
25: Next compteur
26: 'enregistrement du classeur
27: NouvClasseur.SaveAs "C:\Users\Nom_utilisateur\Desktop\"
➥ & NomFichier
28: NouvClasseur.Close
29: Xl.Quit
30: End Sub
Attention
Veillez à personnaliser le chemin précisé pour la fonction GetObject à la ligne 27, sinon cette macro ne
fonctionnera pas.
Lignes 2 à 5, les variables sont déclarées : Xl et NouvClasseur sont des objets de type Excel et
Workbook ; NomFichier servira à stocker le nom d’enregistrement du classeur. Ligne 7, une instance
de l’objet Application d’Excel est créée à l’aide de l’instruction CreateObject, puis affectée à la
variable Xl. Sa propriété Visible est ensuite définie à True afin de faire apparaître la session
Excel à l’écran.
Ligne 11, un nouveau classeur est ajouté à l’objet Application et affecté à la variable objet
NouvClasseur. Notez que, par défaut, un nouveau classeur est créé dans la session Excel à partir
de laquelle le programme est exécuté. Pour qu’il le soit dans la nouvelle session, il est indispen-
sable de faire référence à l’objet Xl dans l’instruction de la ligne 11. Lignes 13 à 16, une feuille
est ajoutée et les deux feuilles sont renommées.
Variables et constantes
Chapitre 6
169
Lignes 17 à 25, le nom d’enregistrement du classeur est défini. La variable NomFichier se voit tout
d’abord affecter le nom Ventes, suivi de la date du jour (Ventes 12/08/2007, par exemple). Ce nom
contient deux fois le caractère barre oblique ( / ), invalide dans les noms de fichier. Lignes 21 à 25,
une boucle For…Next est utilisée pour répéter deux fois le traitement appliqué au nom du classeur
afin de substituer des traits d’union aux barres obliques (les boucles sont étudiées au prochain
chapitre). On utilise pour ce faire les fonctions de manipulation de chaîne InStr, Left, Right et
Len. Instr renvoie la position du caractère / dans la chaîne NomFichier (ligne 22). Len renvoie le
nombre de caractères de NomFichier (ligne 24). Les fonctions Left et Right sont utilisées pour
renvoyer respectivement les caractères situés à gauche et à droite des barres obliques ; un trait
d’union est placé entre les deux chaînes ainsi renvoyées.
Lignes 27 et 28, le classeur est enregistré puis fermé. Ligne 29, la méthode Quit est appliquée à
l’objet Excel, afin de fermer la session créée en début de programme.
Il est important d’affecter la valeur Nothing à une variable objet lorsque celle-ci n’est plus utilisée
par le programme. Vous libérez ainsi l’ensemble des ressources système et mémoire associées à
l’objet. Dans l’exemple de programme de stock précédent, vous devrez placer cette instruction
au-dessus de la ligne 24. La variable ObjetStock sera ainsi libérée avant que la procédure Commandes
ne reprenne la main.
Les noms Données1, …, Donnéesn seront employés par la suite pour affecter des valeurs aux dif-
férents espaces de stockage des variables de type NomType.
Dans l’exemple qui suit, un type de données Membre est créé, afin d’intégrer dans une seule variable
l’ensemble des informations concernant un membre d’une association donnée.
Programmer en Visual Basic
170 Deuxième partie
Type Membre
Prénom As String
Nom As String
Adresse As String
CodePostal As String
Ville As String
Téléphone As String
Age As Byte
End Type
Vous pouvez maintenant créer une nouvelle variable de type Membre. Les informations qu’elle
contient seront ensuite recherchées ou définies en faisant suivre le nom de la variable d’un point,
puis du nom de la donnée (voir figure 6-12) :
Sub NouveauMembre
Dim NouvMembre As Membre
With NouvMembre
.Prénom = "Hélène"
.Nom = "Bienvenue"
.Adresse = "4, rue des oiseaux"
.CodePostal = "56000"
.Ville = "Vannes"
.Téléphone = "00 01 02 03 04"
.Age = 2
End With
MsgBox "Le nouveau membre s'appelle " & NouvMembre.Prénom & " " & _
NouvMembre.Nom, vbOKOnly + vbInformation, "Nouveau membre"
End Sub
Figure 6-12 – Les variables de type personnalisé contiennent autant d’informations que vous le souhaitez.
Notez que, en phase de création, un complément automatique s’affiche lorsque vous faites référence
à une variable de type personnalisé (voir figure 6-13).
Constantes
Les constantes attribuent un nom à une valeur fixe de n’importe quel type. Il est ainsi plus aisé
d’exploiter cette valeur dans le code en faisant référence au nom de la constante, plutôt qu’à la
valeur elle-même. Par ailleurs, si une valeur est susceptible d’être modifiée (TVA, par exemple),
son affectation à une constante simplifiera les éventuelles mises à jour ; il vous suffira en effet de
Variables et constantes
Chapitre 6
171
modifier la constante en un seul endroit, plutôt que de modifier chaque occurrence de la valeur
dans l’ensemble de vos projets.
Figure 6-13 – Le complément automatique d’instruction s’affiche pour les types de données personnalisés.
Attention
Une fois qu’une valeur a été affectée à une constante, celle-ci ne peut être modifiée par la suite.
Par exemple, l’instruction suivante déclare la constante TVA, à laquelle la valeur 20.6 est affectée.
Const TVA As Single = 20.6
Fonction Description
IsArray(MaVar) Renvoie True si MaVar est une variable de matrice ; False dans le cas contraire.
IsDate(MaVar) Renvoie True si MaVar est une variable de date ; False dans le cas contraire.
IsNumeric(MaVar) Renvoie True si MaVar est un nombre ; False dans le cas contraire.
IsObject(MaVar) Renvoie True si MaVar est une variable objet ; False dans le cas contraire.
IsMissing(MaVar) Renvoie True si l’argument optionnel MaVar est de type Variant et n’a pas été passé à la
fonction ou à la procédure en cours.
IsEmpty(MaVar) Renvoie True si MaVar n’a pas été initialisée, c’est-à-dire si aucune valeur ne lui a été
affectée ; False dans le cas contraire. Valide uniquement pour les variables de type Variant.
IsNull(MaVar) Renvoie True si MaVar contient la valeur Null ; False dans le cas contraire. Ne confondez
pas une variable contenant une valeur Null et une variable qui n’a pas été initialisée et ne
contient aucune valeur. Valide uniquement pour les variables de type Variant.
IsError(MaVar) Renvoie True si MaVar stocke une valeur correspondant à l’un des codes d’erreur de VBA.
False dans le cas contraire.
Vous pouvez également utiliser les fonctions VarType ou TypeName pour connaître le type d’une variable.
Utilisez VarType selon la syntaxe suivante :
MaVar = VarType(NomVar)
MaVar (de type Integer) reçoit pour valeur une constante Visual Basic indiquant le type de la variable
NomVar (vbInteger, vbDate, etc.). TypeName s’utilise selon la même syntaxe, MaVar =TypeName(NomVar),
mais renvoie une chaîne de caractères représentant le type de la variable (voir tableau 6-4).
La fonction EntrerUneDate suivante utilise InputBox pour demander une date à l’utilisateur. IsDate
est employée pour vérifier si la valeur entrée est bien valide. Si tel n’est pas le cas, l’utilisateur
est invité à recommencer.
Function EntrerUneDate()
Do
EntrerUneDate = InputBox("Entrez une date", "Vérification du type de données")
Loop Until IsDate(EntrerUneDate) = True
End Function
Info
La fonction InputBox et la structure de contrôle Do…Loop sont présentées au chapitre suivant.
Fonction Description
CBool(MaVar) Renvoie True si MaVar est une valeur numérique différente de 0 ; False si MaVar est égale
à 0. Une erreur est générée si MaVar n’est pas une valeur numérique.
CByte(MaVar) Convertit MaVar en une variable de type Byte.1
CCur(MaVar) Convertit MaVar en une variable de type Currency (monétaire).1
CDate(MaVar) Convertit MaVar en une variable de type Date.1
CDbl(MaVar) Convertit MaVar en une variable de type Double.1
CDec(MaVar) Convertit MaVar en une variable de type Decimal.1
CInt(MaVar) Convertit MaVar en une variable de type Integer.1
CLng(MaVar) Convertit MaVar en une variable de type Long.1
CSng(MaVar) Convertit MaVar en une variable de type Single.1
CVar(MaVar) Convertit MaVar en une variable de type Variant. MaVar doit être une valeur de type Double
pour les nombres et de type String pour les chaînes.
CStr(MaVar) Convertit MaVar en une variable de type String. Si MaVar est un booléen, CStr renvoie
Vrai ou Faux. Si MaVar est une date, CStr la renvoie sous forme de chaîne. Si MaVar est un
nombre, CStr renvoie cette valeur sous forme de chaîne.
1. M aVar doit être une valeur compatible avec le type de données vers lequel s’opère la conversion. Par exemple,
si vous utilisez la fonction Cbyte, MaVar doit être une valeur numérique comprise entre 0 et 255. Sinon, une
erreur « Type incompatible » est générée.
Notez que MaVar peut être une variable ou toute expression valide.
Programmer en Visual Basic
174 Deuxième partie
Dans l’exemple suivant, la constante Pi est déclarée de niveau module privée et est accessible à
toutes les procédures du module.
Option Explicit
Private Pi As Single
Pi = 3.14
Sub Procédure-1 ()
[…] 'Instructions
End Sub
Sub Procédure-n ()
[…] 'Instructions
End Sub
Variables et constantes
Chapitre 6
175
Conseil
Lorsque vous utilisez une valeur définie de façon récurrente dans un projet (une TVA, par exemple), affec-
tez-lui une constante de niveau module publique et utilisez cette constante plutôt que la valeur elle-même
dans les procédures. Si cette valeur est modifiée, il vous suffira de redéfinir l’instruction d’affectation de la
constante pour mettre à jour la totalité du projet.
Variables statiques
Une variable conserve une valeur, modifiable, tant que le programme s’exécute dans son champ
de portée. Lorsque l’exécution du programme sort de la portée de la variable, celle-ci est réini-
tialisée et perd sa valeur. Autrement dit, une variable de niveau procédure conserve sa valeur
tant que la procédure dans laquelle elle est déclarée est en cours d’exécution – même lorsqu’elle
appelle d’autres procédures. Lorsque celle-ci se termine, la variable est réinitialisée. Une variable
de niveau module conserve sa valeur jusqu’à ce que le programme prenne fin.
Pour qu’une variable de niveau procédure conserve sa valeur entre différents appels, substituez
le mot-clé Static à Dim dans l’instruction de déclaration :
Static NomVariable As Type
Astuce
Pour déclarer statiques toutes les variables d’une procédure Sub ou Function, placez le mot-clé Static
devant l’instruction de déclaration de la procédure.
Définition
Automation, ou OLE Automation, est une fonction du modèle d’objets Composant (COM, Component
Object Model). Il s’agit d’un standard qu’utilisent les applications pour exposer leurs objets, méthodes
et propriétés aux outils de développement. Les applications Office supportent Automation. Un classeur
Excel peut ainsi exposer une feuille de calcul, un graphique, une cellule ou une plage de cellules, etc.
Un fichier Word exposera une page, un paragraphe, un mot, ou tout autre objet de son modèle. Visual
Basic pour Applications sait accéder à ces objets, interroger ou redéfinir leurs propriétés, en exécuter les
méthodes, etc.
Pour qu’un projet accède à la bibliothèque d’une autre application, celle-ci doit être référencée
dans le projet : choisissez la commande Références du menu Outils. Dans la boîte de dialogue qui
s’affiche, cochez les cases des bibliothèques qui vous intéressent, puis cliquez sur OK.
Pour réaliser l’exemple suivant, référencez la bibliothèque d’objets Microsoft Word Object Library
à partir d’un projet Excel. Puis créez un nouveau document Word et enregistrez-le sur le Bureau
de Windows, sous le nom MonDoc.docx.
10: MonDoc.Save
11: Set MonDoc = Nothing
12: Word.Application.Quit
13: End Sub
Attention
Veillez à personnaliser le chemin précisé pour la fonction GetObject à la ligne 6, sinon cette macro ne
fonctionnera pas.
Exécutez la procédure, puis ouvrez le fichier Word. Un tableau de quatre colonnes sur trois lignes
a été placé en début de document.
La variable objet MonDoc est déclarée ligne 2. Elle se voit ensuite affecter l’objet Word.Application,
représentant l’application Word, à l’aide de l’instruction Set et de la fonction GetObject (ligne 4). Si
Word n’est pas ouvert, une erreur est générée. Un détecteur d’erreurs est donc placé en ligne 3, de
façon à ignorer l’erreur et à passer à l’instruction suivante. Si, effectivement, une erreur survient
(If Err.Number<>0), la propriété Number de l’objet Err est redéfinie à 0 (ligne 5). Cette éventuelle
erreur étant gérée, MonDoc peut recevoir MonDoc.docx (ligne 6).
La variable MaPosition de type Word.Range est déclarée ligne 7 – l’objet Range de Word repré-
sente une position de curseur dans un document. Ligne 8, la position représentant le début du
document lui est affectée. Un tableau est inséré à cette position ligne 9. Le document est ensuite
sauvegardé. Ligne 11, la variable MonDoc est libérée. Enfin, l’instruction de la ligne 12 quitte Word.
En effet, lorsque vous faites appel à une variable objet d’une autre application, son moteur est
lancé. N’omettez donc pas d’employer la méthode Quit, afin de libérer les ressources occupées.
Info
On distingue, dans l’accès aux objets d’autres applications à l’aide d’Automation, la liaison tardive de la liaison
précoce. La liaison est dite tardive lorsqu’une variable de type Object ou Variant est déclarée (Dim MaVar
As Object). La variable est ensuite initialisée et affectée à un objet de l’application étrangère à l’aide de
la fonction GetObject. On parle de liaison précoce lorsque la variable est déclarée en choisissant un type
identifiant l’application dont on souhaite exploiter les objets (Dim MaVar as Word.Application). Utilisez
de préférence une liaison précoce dans vos programmes. Les performances en seront améliorées et Visual
Basic vérifiera la syntaxe spécifique aux objets de l’application étrangère lors de l’écriture de votre code.
Notez qu’un programme Excel peut exécuter une macro stockée dans une autre application hôte.
Dans l’exemple suivant, la macro MacroWord est exécutée sur un nouveau document à partir
d’Excel. Pour réaliser cet exemple, commencez par créer MacroWord :
1. Lancez Word. Définissez le niveau de sécurité de façon à autoriser l’exécution des macros
(commande Sécurité des macros de l’onglet Développeur).
Info
Le modèle Normal.dotm de Word est l’équivalent du classeur de macros personnel d’Excel : les macros
stockées dans ce modèle sont accessibles à tous les documents Word.
Programmer en Visual Basic
178 Deuxième partie
2. Activez l’onglet Développeur, puis cliquez sur la commande Macros. Avec une version de Word
antérieure à 2007, choisissez Outils > Macro > Macros.
3. Dans la zone Nom de la macro, saisissez MacroWord et, dans la liste déroulante Macros dis-
ponibles dans, sélectionnez Normal.dot (modèle global).
4. Cliquez sur le bouton Créer. Visual Basic Editor s’ouvre sur la fenêtre Code de MacroWord.
5. Complétez le code de la macro de la façon suivante :
Sub MacroWord()
MsgBox "Cette boîte de dialogue est affichée par la macro MacroWord", _
vbOKOnly + vbInformation, "Exécution d'une macro Word à partir d'un programme Excel"
End Sub
6. Enregistrez, puis fermez Word.
Retournez à Visual Basic Editor pour Excel et créez la procédure suivante :
1: Sub ExecuterMacroWord()
2: Dim MonWord As Object
3: Set MonWord = CreateObject("Word.Application")
4: MonWord.Visible = True
5: MonWord.Documents.Add
6: MonWord.Run "MacroWord"
7: Set MonWord = Nothing
8: End Sub
Figure 6-15 – Une macro Excel peut contrôler l’exécution de macros dans d’autres applications hôtes.
Attention
Pour visualiser la boîte de dialogue affichée par la macro Word, vous devez afficher Word. Lorsque vous
cliquez sur le bouton OK, Excel reprend alors la main et la procédure s’achève.
7
Contrôler les programmes VBA
Visual Basic intègre des instructions orientant le comportement d’une macro : les structures de
contrôle – on parle du flux de contrôle d’un programme. La connaissance et la maîtrise de ces
structures constituent un préalable indispensable à la création de programmes VBA souples et
puissants, se comportant différemment selon l’état du document et de l’application au cours de
son exécution, ou suivant les informations fournies par l’utilisateur.
Ce chapitre aborde une à une les structures de contrôle de Visual Basic. Leur combinaison vous
fera gagner un temps précieux dans vos tâches les plus communes comme les plus complexes.
L’instruction GoTo et les fonctions MsgBox et InputBox, ainsi que la collection Dialogs, sont égale-
ment traitées dans ce chapitre. Il ne s’agit pas de structures de contrôle, mais elles servent aussi
à orienter le comportement des programmes VBA et à interagir avec l’utilisateur.
La boucle While…Wend
La structure de contrôle While…Wend répète une série d’instructions tant qu’une condition spécifiée
est remplie. C’est l’une des structures les plus utilisées pour automatiser les tâches répétitives.
Sa syntaxe est la suivante :
While Condition
Série d'instructions
Wend
où Condition est une expression comparant deux valeurs à l’aide d’un opérateur relationnel.
Lorsque la condition spécifiée après While est réalisée, le programme exécute la Série d'instruc-
tions. Lorsque l’instruction Wend est atteinte, le programme retourne à While et teste à nouveau
la condition. Si elle est réalisée, la Série d'instructions s’exécute à nouveau, etc. Dans le cas
contraire, le bloc placé entre While et Wend est ignoré ; et l’exécution du programme se poursuit
alors avec l’instruction située immédiatement après Wend.
Pour poser une condition, on conjugue généralement une expression avec un opérateur relation-
nel, ou opérateur de comparaison, et une valeur. L’opérateur relationnel établit un rapport entre
le résultat renvoyé par l’expression et la valeur. Si ce rapport est vérifié, la condition est respectée.
Le tableau 7-1 présente les opérateurs relationnels de Visual Basic.
Conseil
Deux chaînes de caractères peuvent être comparées à l’aide des opérateurs relationnels =, <, >, etc.
L’opération s’effectue alors entre les codes ANSI attachés aux caractères. Si vous devez effectuer des
comparaisons précises, préférez l’opérateur Like. Celui-ci permet en effet de prendre ou non en compte la
casse et d’utiliser des caractères génériques. Consultez l’aide en ligne pour plus de précisions.
La technique la plus courante pour enregistrer des instructions en boucle consiste à exécuter la
série d'instructions après avoir activé l’Enregistreur de macro, puis à ouvrir la fenêtre Code de
la macro et à y insérer la structure While…Wend.
Contrôler les programmes VBA
Chapitre 7
181
Nous utiliserons une structure While…Wend pour automatiser la saisie d’informations dans une
feuille de calcul. Considérez le classeur Representants par departements représenté à la figure 7-1.
Dans la feuille de calcul active (libellée Representants), les cellules de la ligne 3 contiennent
chacune le nom d’un représentant et, en commentaire, ses initiales. Les colonnes correspondantes
contiennent les numéros des départements dont chaque représentant a la charge.
Le classeur Representants par clients, illustré à la figure 7-2, contient la liste des clients de la
société (colonne A), la ville de chacun (colonne B) et son numéro (colonne D). Les deux premiers
chiffres de ce dernier correspondent au département d’origine du client. La colonne C contiendra
les initiales du représentant en charge du client. Nous profiterons de ce que ces deux classeurs ont
en commun le numéro du département pour automatiser la mise à jour de la colonne C.
Figure 7-2 – La répartition des représentants par clients avant mise à jour de la colonne C.
Programmer en Visual Basic
182 Deuxième partie
La macro suivante extrait les deux premiers chiffres du numéro de client. Elle recherche ensuite
cette valeur dans le classeur Representants par departement, de façon à identifier le représentant
en charge du client, dont les initiales sont alors insérées dans la cellule correspondante de la
colonne C. La structure While…Wend répète cette procédure en boucle. Chaque fois que les initiales
d’un représentant ont été insérées, la cellule Numéro de client suivante est activée. La procédure
s’exécute TANT QUE la cellule sélectionnée contient une valeur.
1: Sub InsererInitialesRepresentants()
2: Dim ClasseurRepresentants As Workbook
3: Dim NumDepartement As String
4: Dim Colonne As Variant
5: Dim Initiales
6: Set ClasseurRepresentants = _
GetObject("C:\Users\Nom_utilisateur\Desktop\Representants par
➥ departements.xlsx")
7: Range("D4").Select
8: While ActiveCell.Value<>""
9: NumDepartement = Left(ActiveCell.Value,2)
10: Colonne = ClasseurRepresentants.Sheets(1).Range("A4:I50").Find(What:=
➥ NumDepartement, LookIn:=xlFormulas, LookAt:=xlWhole).Address
11: Colonne = Range(Colonne).Column
12: Colonne = CInt(Colonne)
13: Initiales = ClasseurRepresentants.Sheets(1).Cells(3,Colonne).Comment.Text
14: ActiveCell.Offset(0,-1).Range("A1").Select
15: ActiveCell.FormulaR1C1 = Initiales
16: ActiveCell.Offset(1,1).Range("A1").Select
17: Wend
18: Set ClasseurRepresentants = Nothing
19: Workbooks("Representants par departements.xlsx").Close
20: End Sub
Lignes 2 à 6 : les variables qui seront exploitées par le programme sont déclarées, et à
ClasseurReprésentant est affecté le classeur Representants par departements.xlsx, situé sur le
Bureau. Ligne 7, la cellule D4 est sélectionnée.
La boucle While…Wend des lignes 8 à 17 s’exécute tant que la cellule sélectionnée contient des
informations. Ligne 9, la fonction Left affecte à la variable NumDepartement les deux caractères de
gauche (correspondant au numéro de département) de la valeur de la cellule active. Cette valeur
est ensuite recherchée dans le classeur des représentants par départements (ligne 10). L’objet
Range renvoyé par la méthode Find est affecté à Colonne – notez que cette variable a été déclarée
de type Variant de sorte qu’elle puisse recevoir des valeurs de différents types. Ligne 11, Colonne
reçoit la valeur correspondant au numéro de la colonne de la cellule trouvée. Ligne 12, la fonction
CInt convertit la valeur de Colonne en un Integer, ce qui la rend utilisable comme argument de la
propriété Cells. Ligne 13, la variable Initiales reçoit pour valeur les initiales du représentant en
charge du département : on lui affecte pour ce faire le texte de commentaire de la cellule située
dans la même colonne que l’objet Range renvoyé par la fonction Find, mais sur la ligne 3 – la ligne
des noms de représentants.
Contrôler les programmes VBA
Chapitre 7
183
Lignes 14 et 16, un déplacement par référence relative aux cellules est effectué. Tout d’abord, la
case située à gauche de la cellule active est sélectionnée et reçoit la valeur de la variable Initiales
(ligne 15). Un déplacement d’une cellule vers la droite puis d’une vers le bas est ensuite effectué.
La cellule active est alors la suivante dans la colonne D. Le mot-clé Wend renvoie l’exécution du
programme à l’instruction While correspondante. Celle-ci vérifie que la cellule active contient des
données. Si tel est le cas, le processus recommence. Lorsque la condition n’est plus vérifiée, les ins-
tructions situées entre While et Wend sont ignorées et le programme se termine avec les instructions
des lignes 18 et 19. Les ressources système occupées par la variable objet ClasseurRepresentants
sont libérées et le classeur est fermé.
Conseil
Pour sécuriser définitivement cette macro, commencez par lui faire activer la feuille devant recevoir les
informations. Elle devra logiquement être stockée dans ClasseurRepresentants.xlsx, puisqu’elle ne servira
qu’à ce classeur. Ainsi, elle ne s’exécutera que si le classeur est ouvert.
La boucle Do…Loop
La structure de contrôle Do…Loop est semblable à While…Wend ; mais elle offre plus de souplesse,
car elle peut se décliner sur quatre modes différents :
• Do While…Loop. Tant que la condition est respectée, la boucle s’exécute.
Do While Condition
Série d'instructions
Loop
Programmer en Visual Basic
184 Deuxième partie
• Do…Loop Until. La boucle s’exécute, puis se répète jusqu’à ce que la condition soit respectée.
Do
Série d'instructions
Loop Until Condition
Le programme suivant utilise une boucle Do While…Loop pour supprimer les doublons dans un
classeur Excel (figures 7-4 et 7-5). On estime, dans cette première version, qu’il existe un doublon
lorsque deux cellules de la colonne A contiennent les mêmes données. Le programme commence
par trier ces dernières. Le contenu de chaque cellule de la colonne A est ensuite comparé à celui
de la cellule suivante. S’ils sont identiques, la ligne de la cellule courante est supprimée.
1: Sub SuppressionDoublons()
2: Dim CelluleCourante As Range
3: Dim CelluleSuivante As Range
4: Set CelluleCourante = ActiveSheet.Range("A1")
5:
6: 'Tri des données sur la cellule A1
7: ActiveSheet.Range("A1").Sort key1:=Range("A1"), _
8: Order1:=xlAscending, Header:= xlGuess, OrderCustom:=1, _
9: MatchCase:=False, Orientation:=xlTopToBottom
10: 'Boucle
11: Do While IsEmpty(CelluleCourante) = False
12: Set CelluleSuivante = CelluleCourante.Offset(1,0)
13: If CelluleSuivante.Value = CelluleCourante.Value Then
14: CelluleCourante.EntireRow.Delete
15: End If
16: Set CelluleCourante = CelluleSuivante
17: Loop
18: End Sub
MatchCase et Orientation correspondent au respect de la casse lors du tri et à son orientation (ici
de haut en bas).
Lignes 11 à 17, une boucle Do While…Loop est utilisée pour tester toutes les cellules. CelluleCourante
est testée, puis reçoit la valeur stockée dans CelluleSuivante. La boucle s’exécute tant que
CelluleCourante n’est pas vide [IsEmpty(CelluleCourante) = False].
Ligne 12, la propriété Offset est utilisée pour attribuer à CelluleSuivante la case en-dessous dans la
même colonne. Lignes 13 à 15, une instruction conditionnelle supprime la ligne de CelluleCourante
(CelluleCourante.EntireRow) s’il y a un doublon avec la cellule suivante. CelluleCourante reçoit
ensuite la cellule stockée dans CelluleSuivante (ligne 16).
Ligne 17, l’instruction Loop renvoie le programme à l’instruction While correspondante. La condi-
tion est de nouveau évaluée, et le corps de la boucle s’exécute si elle est vérifiée. Lorsqu’elle n’est
plus vérifiée, le programme se poursuit avec l’instruction située immédiatement sous Loop. En
l’occurrence, il prend fin.
Le programme fonctionne correctement, mais ne prend en compte que le contenu des cellules de
la colonne A pour déterminer les doublons. La procédure suivante supprime une ligne uniquement
si les données sont également identiques dans les colonnes B, C et D.
Programmer en Visual Basic
186 Deuxième partie
Attention
Veillez à ajouter des données dans les colonnes C et D avant d’exécuter la nouvelle version de la macro
SuppressionDoublons.
1: Sub SuppressionDoublons()
2: Dim Cellulecourante As Range
3: Dim Cellulesuivante As Range
4: Set Cellulecourante = ActiveSheet.Range("A1")
5:
6: 'Tri des données sur la cellule A1
7: ActiveSheet.Range("A1").Sort Key1:=Range("A1"), Order1:=xlAscending,
➥ Key2:=Range("B1"), _
8: Order2:=xlAscending, Key3:=Range("C1"), Order3:=xlAscending,
➥ Header:=xlGuess, _
9: OrderCustom:=1, MatchCase:=False, Orientation:=xlTopToBottom
10: 'Boucle et test des cellules
11: Do While IsEmpty(Cellulecourante) = False
12: Set Cellulesuivante = Cellulecourante.Offset(1,0)
13: If Cellulesuivante.Value = Cellulecourante.Value Then
14: If LignesIdentiques(Cellulecourante, Cellulesuivante) = True Then
15: Cellulecourante.EntireRow.Delete
16: End If
17: End If
18: Set Cellulecourante = Cellulesuivante
19: Loop
20: End Sub
21:
22: Function LignesIdentiques(CellCourante As Range, CellSuivante As Range)
➥ As Boolean
23: If CellCourante.Offset(0,1).Value <> CellSuivante.Offset(0,1).Value Then
24: LignesIdentiques = False
25: ElseIf CellCourante.Offset(0,2).Value <> CellSuivante.Offset(0,2).Value Then
26: LignesIdentiques = False
27: ElseIf CellCourante.Offset(0,3).Value <> CellSuivante.Offset(0,3).Value Then
28: LignesIdentiques = False
29: Else
30: LignesIdentiques = True
31: End If
32: End Function
False est affectée à la fonction (lignes 24, 26 et 28). Dans le cas contraire, la fonction renvoie
True (ligne 30). La procédure appelante reprend alors la main, et l’instruction de la ligne 15 est
exécutée si la fonction a renvoyé True. Dans le cas contraire, la condition n’est pas vérifiée et la
cellule suivante est testée.
Rappel
Pour interrompre une macro qui ne fonctionne pas correctement (qui exécute une boucle sans fin, par
exemple), appuyez sur Ctrl+Pause, puis voyez le chapitre 11.
La boucle For…Next
La structure de contrôle For…Next répète une série d’instructions un nombre de fois déterminé
dans le code, en utilisant un compteur et selon la syntaxe suivante :
For compteur = x To y Step Pas
série d'instructions
Next compteur
La macro exécute en boucle la série d’instructions spécifiée entre For et Next, en incrémentant
la variable compteur de la valeur de Pas à chaque passage de la boucle. Si l’argument Step est
omis, le compteur est incrémenté de 1. Tant que la valeur de compteur est inférieure à y, la boucle
se répète ; lorsque la condition n’est plus vérifiée, la procédure se poursuit avec les instructions
situées derrière l’instruction Next.
La procédure suivante applique un ombrage de cellules à une ligne sur deux d’une feuille de calcul
Excel, afin d’obtenir une mise en forme semblable à celle représentée à la figure 7-6.
1: Sub FormaterClasseur()
2: Dim compteur As Integer
3: Dim MaLigne As Variant
4: Cells.Interior.ColorIndex = 2
5: MaLigne = Range("A1").End(xlDown).Address
6: MaLigne = Range(MaLigne).Row
7: If Not MaLigne/2 = Int(MaLigne/2) Then
8: MaLigne = MaLigne + 1
9: End If
10: For compteur = 2 To MaLigne Step 2
11: Range(compteur & ":" & compteur).Select
12: Selection.Interior.ColorIndex = 15
13: Next compteur
14: End Sub
Deux variables sont tout d’abord déclarées. La propriété ColorIndex de l’objet Interior de tous les
objets de la collection Cells est ensuite définie à 2 (ligne 4) – ce qui revient à appliquer la couleur
de fond blanche à l’ensemble des cellules de la feuille active.
Programmer en Visual Basic
188 Deuxième partie
Les instructions des lignes 4 à 9 servent à déterminer jusqu’à quelle ligne le formatage doit s’effec-
tuer. L’adresse de la dernière cellule non vide sous la cellule A1 est affectée à la variable MaLigne
(ligne 5), qui reçoit ensuite pour valeur le numéro de ligne de cette cellule (ligne 6). Une instruction
conditionnelle If…End If est utilisée pour vérifier que MaLigne est une valeur paire (lignes 7 à 9). Si tel
n’est pas le cas (si MaLigne divisée par 2 n’est pas un nombre entier), MaLigne est incrémentée de 1.
La boucle For…Next peut maintenant être exécutée. Le compteur de la boucle commence à 2 et
est incrémenté de 2 à chaque passage de la boucle, jusqu’à atteindre la valeur MaLigne (ligne 10).
À chaque passage de la boucle, la ligne correspondant à la valeur de la variable compteur est
sélectionnée (ligne 11), et l’ombrage de cellule correspondant à la valeur 15 de la propriété
ColorIndex lui est appliqué (ligne 12).
Ligne 14, la fonction LignesIdentiques est appelée et reçoit maintenant une valeur de type Byte
pour l’argument Num (ici, 3).
La fonction LignesIdentiques contrôle ensuite Num cellules afin de définir si la ligne doit ou non
être supprimée. Elle reçoit d’abord la valeur True. La boucle For…Next (lignes 26 à 31) s’exécute
ensuite Num fois. Les cellules testées à chaque passage de la boucle correspondent à un déplace-
ment de Num cases vers la droite. Si deux contenus différents sont décelés (ligne 27), la valeur
False est affectée à LignesIdentiques et l’instruction Exit For entraîne la sortie de la boucle. Si les
contenus des cellules comparées sont toujours identiques, la boucle prend fin après Num passages
et la fonction garde la valeur True.
Lignes 2 et 3, les variables sont déclarées. Ligne 4, on affecte à DerniereLigne le numéro de la
dernière ligne employée. On se sert pour cela de la propriété UsedRange qui renvoie la zone utilisée
sur la feuille active, c’est-à-dire la zone rassemblant l’ensemble des cellules contenant des données
sur la feuille. La propriété Row renvoie le numéro de la première ligne de cette zone. En retirant 1
à cette valeur, on obtient le nombre de lignes vides précédant la zone utilisée. L’expression
UsedRange.Rows.Count renvoie le nombre de lignes de la zone. En additionnant ces deux valeurs,
nous obtenons le numéro de la dernière ligne de la zone utilisée.
Une boucle For…Next avec un pas négatif (Step –1) est ensuite employée pour parcourir les lignes à
vérifier en commençant par la dernière. Ligne 6, on vérifie si la ligne testée est vide à l’aide de la
fonction Excel CountA qui renvoie le nombre de cellules de la zone interrogée (ici la ligne entière,
Rows(Compteur)) contenant des données. Si la ligne est vide (CountA renvoie 0), elle est supprimée.
Le programme passe à la valeur suivante, en décrémentant notre compteur de 1.
L’utilisation d’un pas négatif nous assure ici que le programme teste toutes les lignes. En effet, si
nous avions employé un pas positif et parcouru la zone utilisée de la première ligne à la dernière,
la suppression d’une ligne aurait entraîné le décalage vers le haut de la suivante, qui n’aurait donc
pas été traitée lors du prochain passage de la boucle.
Figure 7-7 – Pour stocker les valeurs d’une feuille Excel dans une variable de matrice,
utilisez des boucles For…Next imbriquées.
Dim MonTableau() As Single
1: Sub BouclesForNextImbriquées()
2: Dim DerniereLigne As Byte
3: DerniereLigne = Range("A2").End(xlDown).Row
4: Dim NbreDeLignes As Byte
5: NbreDeLignes = DerniereLigne - 1
Contrôler les programmes VBA
Chapitre 7
191
6: ReDim MonTableau(NbreDeLignes,4)
7: Call AffecterValeursTableau(NbreDeLignes)
8: End Sub
9: Sub AffecterValeursTableau(DerniereLigneTableau)
10: Dim CompteurLignes As Byte
11: Dim CompteurColonnes As Byte
12: For CompteurLignes = 1 To DerniereLigneTableau
13: For CompteurColonnes = 1 To 4
14: MonTableau(CompteurLignes, CompteurColonnes) = _
Cells(CompteurLignes+1, CompteurColonnes+1)
15: Next CompteurColonnes
16: Next CompteurLignes
17: End Sub
La variable de matrice MonTableau() est déclarée dans la section Déclarations du module, afin
d’être accessible à toutes les procédures de ce dernier. La procédure BouclesForNextImbriquées la
redimensionne de sorte qu’elle accueille l’ensemble des données de la feuille Excel active. Pour
un descriptif des instructions de cette procédure, reportez-vous à la section « Variables de matrice
dynamiques » du chapitre précédent. Elle appelle ensuite la procédure AffecterValeursTableau
en lui passant la valeur de la variable NbreDeLignes.
La procédure AffecterValeursTableau commence par créer deux variables numériques de type
Byte, qui serviront de compteur à chacune des boucles For…Next (lignes 10 et 11). La première
boucle For…Next (lignes 12 à 16) utilise CompteurLignes pour répéter son instruction autant de fois
qu’il y a de lignes à stocker. La boucle For…Next imbriquée (lignes 13 à 15) utilise CompteurColonnes
afin de répéter ses instructions pour chacune des colonnes. L’instruction ligne 14 affecte une
valeur à un des espaces de stockage de MonTableau, selon l’ordre suivant :
1. CompteurLigne = 1 : la boucle For…Next imbriquée s’exécute quatre fois et affecte les valeurs
des cellules B2 à E2 à MonTableau(1,1), MonTableau(1,2), MonTableau(1,3) et MonTableau(1,4).
2. CompteurLigne = 2 : la boucle For…Next imbriquée s’exécute quatre fois et affecte les valeurs
des cellules B3 à E3 à MonTableau(2,1), MonTableau(2,2), MonTableau(2,3) et MonTableau(2,4).
[etc.]
La boucle For Each…Next
Cette structure de contrôle généralise un traitement à l’ensemble des objets d’une collection et
s’utilise selon la syntaxe suivante :
For Each élément In Collection
Instructions
Next élément
où élément est une variable de type Object ou Variant, utilisée pour représenter chaque objet de la
collection. Les Instructions sont exécutées une fois pour chaque objet de la collection. La pro-
cédure suivante utilise une structure For Each…Next pour appliquer une couleur de police rouge
(ColorIndex = 3) à tous les objets Cells de l’objet Selection (toutes les cellules de la sélection en
cours) dont la valeur est supérieure à 1 000.
Programmer en Visual Basic
192 Deuxième partie
Sub FortesValeursEnRouge()
Dim cellule As Range
For Each cellule In Selection.Cells
If cellule.Value>1000 Then
cellule.Font.ColorIndex = 3
End If
Next cellule
End Sub
La procédure suivante enregistre tous les classeurs Excel ouverts (au format xlsx) – à l’exception
de PERSONAL.XLSB – vers le format Excel 97-2003 (xls) et les ferme :
1: Sub EnregistrerFormatExcel4EtFermer()
2: Dim Classeur As Workbook
3: Dim position As Byte
4: Dim NomClasseur As String
5: For Each Classeur In Workbooks
6: If Not Classeur.Name="PERSONAL.XLSB" Then
7: NomClasseur = Classeur.FullName
8: position = InStr(NomClasseur, ".xlsx")
9: NomClasseur = Left(NomClasseur, position-1) & ".xls"
10: Classeur.SaveAs FileName:=NomClasseur, _
FileFormat:=xlExcel8
11: Classeur.Close
12: End If
13: Next Classeur
14: End Sub
Les lignes 2 à 4 déclarent les variables nécessaires au programme. La condition de la ligne 6
vérifie que Classeur n’est pas PERSONAL.XLSB. On utilise pour de faire l’opérateur logique
Not (présenté à la fin de ce chapitre) et la propriété Name qui, attachée à un objet Workbook, renvoie
le nom de fichier de ce dernier (sans le chemin).
Ligne 7, la variable NomClasseur se voit affecter le nom complet du classeur – le chemin suivi du
nom de fichier – renvoyé par la propriété FullName. Les fonctions InStr et Left sont utilisées pour
substituer l’extension .xls à l’extension .xlsx, afin de définir des noms d’enregistrement corrects
pour les fichiers. InStr sert à comparer deux chaînes de caractères. Ici, elle renvoie une valeur
numérique représentant la position de «.xlsx» dans la chaîne NomClasseur. La fonction Left sert
à renvoyer un nombre déterminé de caractères situés à gauche d’une chaîne. Ici, elle renvoie les
(position–1) premiers caractères de la chaîne NomClasseur, c’est-à-dire le nom du fichier sans
l’extension «.xlsx». Il suffit alors de concaténer la valeur de NomClasseur et la chaîne «.xls» pour
obtenir un nom du fichier à sauvegarder. La méthode SaveAs est ensuite appliquée à l’objet Classeur,
le nom ainsi défini est affecté à l’argument FileName, et la constante Excel xlExcel8 à l’argument
FileFormat. Enfin, la méthode Close ferme le document ainsi enregistré.
Info
Le traitement des chaînes de caractères est un sujet incontournable. Vous serez inévitablement amené à
manipuler des chaînes (composées de lettres comme de chiffres) afin d’en extraire les données voulues
ou de les modifier. Les fonctions de traitement des chaînes de caractères sont présentées au chapitre 12.
Contrôler les programmes VBA
Chapitre 7
193
Lignes 2 à 5, les variables sont déclarées. Lignes 6 à 13, MonWord reçoit l’objet Word.Application.
Notez que la méthode GetObject est utilisée avec un gestionnaire d’erreurs afin de capturer l’erreur
générée si Word n’est pas ouvert, auquel cas la méthode CreateObject crée une nouvelle instance
Programmer en Visual Basic
194 Deuxième partie
de l’application (ligne 9) et l’objet Err qui reçoit l’erreur est réinitialisé (ligne 10). Lignes 12 et 13,
l’application Word s’affiche et un nouveau document est créé.
Lignes 14 à 31, la première boucle For Each…Next parcourt la collection des feuilles du classeur.
Pour chacune, le document Word reçoit un texte formaté (lignes 15 à 22). Nous utilisons pour cela
une structure With…End With qui définit la police employée (Arial, corps 13), avant d’insérer le texte
«Formules de la feuille : « suivi du nom de la feuille. La taille de la police est ensuite redéfinie à 11.
La seconde structure For Each…Next (lignes 23 à 30) prend alors la main et traite chacune des
cellules de la collection MaFeuille.Cells(1,1).CurrentRegion.Cells. Notez que l’on utilise ici
la propriété CurrentRegion pour définir la zone courante à partir de la cellule A1 de la feuille.
À chaque occurrence de la boucle, on vérifie si la cellule contient une formule (ligne 24) et, si
tel est le cas, on l’insère dans le document Word, précédée de l’adresse de la cellule concernée.
Lorsque toutes les cellules ont été traitées, la boucle imbriquée prend fin et l’instruction de la
ligne 31 appelle le passage suivant de la structure For Each…Next principale.
Lorsque la Condition spécifiée est remplie, la Série d'instructions est exécutée ; sinon, la pro-
cédure se poursuit avec l’instruction située immédiatement après End If.
La macro Auto_Open suivante utilise une structure If…End If pour contrôler l’affichage de la boîte
de dialogue présentée à la figure 7-9. Elle recourt pour ce faire à la fonction Date, qui renvoie la
date du jour.
Rappel
Une macro Auto_Open s’exécute automatiquement à l’ouverture du classeur Excel dans lequel elle est
stockée.
Sub Auto_Open()
If Date>"30/11/17" and Date<"08/12/17" Then
MsgBox "Attention ! Remise des budgets " & _
"prévisionnels le 8 décembre.", _
vbOKOnly + vbCritical, "Soyez prêt !"
End If
End Sub
Figure 7-9 – Ce message s’affiche à chaque ouverture du classeur effectuée entre le 1er et le 7 décembre.
La valeur attachée à l’opérateur relationnel dans une condition varie selon l’objet de la compa-
raison ; il peut s’agir d’une chaîne de caractères, d’un nombre, ou encore d’une valeur booléenne.
Dans l’exemple suivant, l’instruction If assure que les conditions nécessaires au bon fonctionne-
ment du programme sont réalisées (en l’occurrence que deux fenêtres de document sont ouvertes).
Si ce n’est pas le cas, un message s’affiche à l’attention de l’utilisateur et l’instruction Exit Sub
entraîne la sortie de la procédure.
Programmer en Visual Basic
196 Deuxième partie
Sub VérifierConditions
If Workbooks.Count<>2 Then
MsgBox "La macro ne peut être exécutée. " & _
"Deux classeurs doivent être ouverts."
Exit Sub
End if
'Instructions exécutées si deux classeurs sont ouverts
End Sub
Une structure If…Then…Else autorise un nombre indéterminé de conditions. Vous pouvez ainsi
envisager les différents cas possibles dans une situation particulière et indiquer à la procédure
les instructions à exécuter dans chacun de ces cas.
L’instruction répond alors à la syntaxe suivante :
If condition1 Then
Série d'instructions 1
ElseIf condition2 Then
Série d'instructions 2
ElseIf condition3 Then
Série d'instructions 3
…
Else
Série d'instructions n
End If
Contrairement à ElseIf, l’instruction Else ne pose aucune condition : elle apparaît en dernière
position, et les instructions qui lui sont attachées sont automatiquement exécutées si aucune des
conditions posées auparavant n’a été réalisée. En revanche, si l’une des conditions posées par une
instruction If ou ElseIf est réalisée, la macro exécute les instructions qui lui sont attachées, puis
ignore tout le reste et se poursuit avec les instructions situées après End If.
L’instruction ElseIf, comme Else, est facultative. Une instruction conditionnelle peut être compo-
sée d’une ou de plusieurs instructions ElseIf et ne pas présenter d’instruction Else, et inversement.
La fonction suivante détermine la valeur d’une remise sur un achat, puis insère cette valeur ainsi
que le prix après remise dans la feuille de calcul.
1: Sub CalculRemiseEtPrixDefinitif()
2: Dim PrixAvantRemise As Single, PrixDefinitif As Single
3: PrixAvantRemise = ActiveSheet.Range("C11")
4: PrixDefinitif = PrixAvecRemise(PrixAvantRemise)
5: ActiveSheet.Range("C13").Value = PrixDefinitif
6: End Sub
7: Function PrixAvecRemise(ValeurAchat)
8: Dim PourcentageRemise As Single
9: If ValeurAchat<=1000 Then
10: PourcentageRemise = 0
11: ElseIf ValeurAchat>1000 And ValeurAchat<=2000 Then
12: PourcentageRemise = 0.1
Contrôler les programmes VBA
Chapitre 7
197
Info
Une instruction conditionnelle peut aussi s’écrire sur une seule ligne, en utilisant deux points (:) comme
séparateurs entre les instructions à exécuter si la condition est vérifiée. L’instruction End If est alors
omise :
If Condition Then Instruction1 : Instruction2 : … : InstructionN
Par exemple, l’instruction :
If Selection.Font.Italic()=True Then
Selection.Font.Italic()=False
End If
est aussi valide sous la forme :
If Selection.Font.Italic()=True Then Selection.Font.Italic()=False
Voici un exemple avec plusieurs instructions sur une même ligne :
If Selection.Font.Italic()=True Then Selection.Font.Italic()=False :
➥ Selection.Font.Bold=True
Conditions imbriquées
Les conditions imbriquées permettent de prendre en considération un grand nombre de possibilités
lors de l’exécution du programme.
L’exemple suivant est composé d’une première instruction conditionnelle qui vérifie si deux
fenêtres sont ouvertes avant de s’exécuter. Nous y avons imbriqué une instruction conditionnelle,
qui modifie la boîte de dialogue affichée en fonction du nombre de fenêtres ouvertes.
Programmer en Visual Basic
198 Deuxième partie
Sub
Workbooks.Count
If = 2 If <> 2
If < 2 If > 2
Message 1 Message 2
Exit Sub
Instructions
de la macro
End Sub
Lorsque la valeur renvoyée par Expression correspond à l’une de celles posées par les instructions
Case, les Instructions correspondantes s’exécutent et la procédure se poursuit avec l’instruction
qui suit End Select. Si aucune des valeurs ne correspond, les instructions attachées à Case Else,
s’il existe, sont exécutées.
Le programme suivant détermine la valeur de la variable Reduction, selon le contenu de la cel-
lule D7 de la feuille 1 dans le classeur commande.xlsx (notez que celui-ci doit être ouvert au
moment de l’exécution de la macro). Une boîte de dialogue est ensuite affichée, afin d’informer
l’utilisateur de la remise qui sera effectuée.
1: Sub AffichageReduction()
2: Dim Reduction As Variant
3: Dim LongueurChaîne As Byte
4: Reduction = CalculerValeurReduction _
(Workbooks("commande.xlsx").Sheets(1).Range("D7").Value)
5: LongueurChaîne = Len(Reduction)
6: If LongueurChaîne=3 Then Reduction = Reduction & "0"
7: MsgBox "La remise effectuée sera de " & Reduction & " %."
8: End Sub
9: Function CalculerValeurReduction(PrixCommande)
10: Select Case PrixCommande
11: Case 0 To 999.99
12: CalculerValeurReduction = 0
13: Case 1000 To 1999.99
14: CalculerValeurReduction = 0.1
15: Case 2000 To 2999.99
16: CalculerValeurReduction = 0.25
17: Case Else
18: CalculerValeurReduction = 0.4
19: End Select
20: End Function
Programmer en Visual Basic
200 Deuxième partie
La variable Reduction est tout d’abord déclarée de type Variant. Elle stockera en effet une valeur
numérique, qui sera ensuite manipulée en tant que chaîne de caractères. L’instruction d’affectation
de la ligne 4 appelle la fonction CalculerValeurReduction, en lui passant la valeur de la cellule D7
de la première feuille du classeur commande.xlsx.
La fonction CalculerValeurReduction utilise une structure Select Case pour renvoyer une valeur
fonction de l’argument PrixCommande (ici la valeur de la cellule D7). Le mot-clé To est utilisé pour
définir des plages de valeurs (0 à 999.99, 1000 à 1999.99, etc.). La procédure principale reprend
ensuite la main.
Les instructions des lignes 5 et 6 servent à formater la chaîne stockée dans la variable Reduction.
La fonction Len renvoie la longueur (le nombre de caractères) de Reduction, qui est stockée dans
LongueurChaîne. Si la chaîne comprend trois caractères, un 0 est ajouté à la fin (0,1 et 0,4 deviennent
respectivement 0,10 et 0,40). Enfin, l’instruction de la ligne 7 affiche une boîte de dialogue infor-
mant l’utilisateur de la valeur de la remise qui sera effectuée.
Info
Dans les instructions Visual Basic, c’est le point qui sert de séparateur décimal dans les valeurs numé-
riques. Cependant, lorsque vous affichez une valeur numérique sous forme de chaîne – comme l’instruc-
tion de la ligne 7 de l’exemple précédent –, la virgule est utilisée.
L’étiquette spécifiée après GoTo doit être placée au début d’une ligne indépendante, située avant
l’instruction sur laquelle on veut brancher la procédure ; elle doit être immédiatement suivie des
deux points « : ». Une instruction GoTo ne peut renvoyer qu’à une étiquette se trouvant dans la
même procédure.
Les instructions GoTo compliquent la lecture du code. Préférez-leur les structures de contrôle.
• MsgBox affiche un message à l’attention de l’utilisateur et lui propose de choisir entre différentes
possibilités en cliquant sur l’un des boutons de commande affichés.
La fonction InputBox
La fonction VBA InputBox affiche une boîte de dialogue contenant une zone de texte légendée,
afin d’inviter l’utilisateur à y saisir l’information attendue ; cette dernière est renvoyée sous forme
de chaîne de caractères et stockée dans une variable pour être ensuite exploitée par le programme.
La fonction InputBox s’utilise selon la syntaxe suivante :
InputBox(prompt, title, default)
prompt, title et default sont des arguments nommés de type String. prompt est le message affiché
dans la boîte de dialogue afin de légender la zone de texte. L’argument title, facultatif, corres-
pond au texte affiché dans la barre de titre de la boîte de dialogue ; s’il est omis, c’est le nom de
l’application qui apparaît. default est facultatif aussi ; il définit ce qui apparaît par défaut dans
la zone de texte.
La procédure suivante affiche la boîte de dialogue représentée à la figure 7-12.
Sub UtilisationDeInputBox()
Dim DateVal As String
DateVal = InputBox("Date de validité :", "Nouveau membre", Date)
End Sub
Pour stocker l’information fournie par l’utilisateur, il suffit d’affecter la fonction à une variable
de type String ou Variant, selon la syntaxe suivante :
Variable = InputBox(prompt, title, default)
Programmer en Visual Basic
202 Deuxième partie
Conseil
Si l’affichage d’une réponse par défaut n’est pas indispensable, il peut se révéler fort pratique pour orienter
l’utilisateur lorsque l’information demandée autorise plusieurs formats. Par exemple, si vous avez besoin
d’une date au format jj/mm/aa, l’affichage d’une date hypothétique à l’aide de l’argument default indiquera
à l’utilisateur le format attendu.
Vous pouvez afficher des variables ou des caractères réservés (comme le guillemet ou la virgule)
dans une boîte de dialogue. Pour ce faire, on utilise :
• l’opérateur de concaténation & ;
• la fonction Chr, pour afficher un caractère réservé en spécifiant son code ASCII (entre 1 et 32).
La fonction InputBox se présente alors ainsi :
InputBox("Texte" & variable + Chr(CodeAscii) + "Texte", "Titre", "Entrée par défaut")
Dans l’exemple suivant, la fonction InputBox demande à l’utilisateur d’indiquer une date d’échéance
pour les opérations en cours. La procédure met ensuite en valeur les cellules sélectionnées dont
la date est supérieure à la date indiquée.
1: Sub VerifierEcheances()
2: 'Vérifier qu'il existe une plage de cellules sélectionnée
3: Dim ZoneATester As String
4: ZoneATester = ActiveWindow.RangeSelection.Address
5: If ZoneATester=Null Then
6: MsgBox "Sélectionnez la plage de cellules à tester.", _
vbOKOnly + vbInformation
Contrôler les programmes VBA
Chapitre 7
203
7: Exit Sub
8: End If
La procédure commence par vérifier qu’une plage de cellules a été sélectionnée dans le classeur
actif (lignes 2 à 8). Elle affecte pour cela l’adresse de la sélection en cours à la variable ZoneATester.
Si aucune zone n’est sélectionnée (ZoneATester=Null), un message s’affiche à l’attention de l’uti-
lisateur et l’instruction de la ligne 7 entraîne la sortie de la procédure.
La fonction InputBox demande ensuite à l’utilisateur d’indiquer une date d’échéance (ligne 11). La
fonction Date est utilisée pour déterminer la valeur par défaut de la zone de texte. Elle renvoie la
date du jour, à laquelle on ajoute 30 jours. La chaîne renvoyée par la fonction InputBox est stockée
dans la variable DateEcheance de type Variant. Ligne 12, la fonction CDate convertit DateEcheance
en une variable de type Date.
Attention
Si vous déclarez DateEcheance de type String, le programme fonctionnera correctement, mais l’ins-
truction de conversion de type de données de la ligne 12 ne modifiera rien. L’instruction conditionnelle de
la ligne 17 effectuera alors une comparaison entre les chaînes de caractères, et non entre les dates. Le
programme se déroulera correctement, mais produira des résultats erronés.
La procédure teste ensuite l’ensemble des cellules sélectionnées. Une variable objet de type Range
est déclarée ligne 14. Lignes 15 à 22, une structure de contrôle For Each…Next est utilisée pour
tester tous les objets Range de la collection contenue dans la sélection en cours.
L’instruction conditionnelle de la ligne 16 vérifie que la cellule traitée contient des données de
type Date. Si ce n’est pas le cas, elle est ignorée et la boucle se poursuit avec la cellule suivante. Si
les données sont de type Date, la structure conditionnelle des lignes 17 à 19 est exécutée : quand
la valeur de la cellule est supérieure à DateEcheance, elle est peinte en jaune (ColorIndex=6). La
figure 7-14 représente une feuille de calcul après passage de la macro VerifierEcheances (l’utili-
sateur a indiqué le 16/03/2017 pour date d’échéance).
Programmer en Visual Basic
204 Deuxième partie
Figure 7-14 – Les cellules dont la date est supérieure à l’échéance indiquée par l’utilisateur
sont mises en évidence (cadre gris clair).
Attention
Si l’utilisateur clique sur le bouton Annuler ou sur le bouton de fermeture d’une boîte de dialogue affichée
à l’aide de InputBox, la fonction renvoie une chaîne vide. Une erreur pourra alors être générée par le pro-
gramme s’il tente de l’exploiter. Placez une instruction If…Then…Else pour vérifier que la valeur retournée
par InputBox n’est pas une chaîne vide. Les instructions suivantes pourront être placées sous la ligne 11
du programme précédent, afin de mettre fin à la procédure si l’utilisateur annule la saisie d’une valeur.
If DateEcheance="" Then
Exit Sub
End if
De la même façon, si l’utilisateur saisit n’importe quoi d’autre que la valeur attendue, le programme pourra
générer une erreur ou produire des résultats erronés. Utilisez les instructions de contrôle de type de don-
nées présentées au chapitre 6 pour vous assurer que les informations fournies sont valides. Vous appren-
drez à gérer ces éventuelles erreurs au chapitre 11.
La méthode InputBox
L’objet Application d’Excel possède une méthode InputBox, que vous pouvez substituer à la fonc-
tion éponyme de Visual Basic. L’intérêt est qu’elle permet de spécifier le type de données qui sera
renvoyé. Utilisez cette méthode selon la syntaxe suivante :
Application.InputBox(prompt, title, default, left, top, helpFile, helpContextID, type)
Si vous ne spécifiez pas de valeur pour l’argument title, le titre par défaut de la boîte de dialogue
sera « Entrée ». Les arguments nommés left et top spécifient l’emplacement de la boîte de dialogue
sur l’écran au moment de son affichage, tandis que helpFile et helpContextID servent à associer des
fichiers d’aide à la boîte de dialogue. Ils existent aussi pour la fonction InputBox de Visual Basic.
Contrôler les programmes VBA
Chapitre 7
205
L’argument de type Variant type est facultatif. Il peut prendre l’une des valeurs présentées dans le
tableau 7-2 et détermine le type de données renvoyé. La méthode InputBox peut renvoyer plusieurs
types de données définis ; dans ce cas, affectez à type la somme des valeurs correspondantes
(tableau 7-2). Par exemple, pour que l’utilisateur soit autorisé à indiquer un nombre ou une réfé-
rence de cellules, vous lui affecterez la valeur 9 (1 + 8).
Conseil
Si l’information saisie par l’utilisateur dans la zone de texte ne correspond pas au type de données déclaré
pour la méthode InputBox, une erreur sera générée. Pensez à créer un gestionnaire d’erreurs (voir cha-
pitre 11).
L’autre avantage de la méthode InputBox d’Excel sur sa concurrente Visual Basic est de permettre
à l’utilisateur de sélectionner une plage de cellules avant de cliquer sur le bouton OK. Il est ainsi
possible de sélectionner un classeur ou une feuille spécifique, puis de sélectionner la plage vou-
lue. Les coordonnées de celles-ci s’affichent alors dans la zone de texte de la boîte de dialogue.
L’instruction suivante affiche une boîte de dialogue qui accepte pour valeur une référence de cellule.
L’utilisateur est invité à sélectionner une plage de cellules dans la feuille active (voir figure 7-15).
Sub RenvoyerUnePlageAvecInputBox()
Dim MaPlage As Range
Set MaPlage = Application.InputBox(prompt:="Sélectionnez la plage de cellules.", _
Title:="Contrôle des échéances", Left:=3, Top:=-80, Type:=8)
End Sub
Conseil
Lorsque vous utilisez la fonction InputBox d’Excel pour inviter l’utilisateur à sélectionner une plage de cel-
lules, tirez profit des arguments Left et Top. Si la boîte de dialogue s’affiche dans l’angle supérieur gauche
de la fenêtre, l’utilisateur n’aura pas besoin de la déplacer pour sélectionner des cellules sur la feuille.
Programmer en Visual Basic
206 Deuxième partie
Figure 7-15 – La zone de texte de la boîte de dialogue reflète la sélection effectuée sur la feuille Excel.
La fonction MsgBox
La fonction MsgBox affiche une boîte de dialogue présentant un message et des boutons de com-
mande, pour donner une information à l’utilisateur ou obtenir une réponse à une question qui
orientera l’exécution du programme. Une valeur de type Integer est renvoyée en fonction du
bouton sur lequel l’utilisateur a cliqué, et stockée dans une variable pour être ensuite exploitée
par le programme.
La fonction MsgBox s’utilise selon la syntaxe suivante :
Variable = MsgBox(prompt, buttons, title)
prompt est un argument nommé de type String, correspondant au message affiché dans la boîte de
dialogue. buttons est un argument nommé de type numérique facultatif. Il détermine les boutons
affichés dans la boîte de dialogue, le symbole identifiant le type du message (information, ques-
tion, etc.) et le bouton par défaut. Si cet argument est omis, un seul bouton libellé OK s’affiche
et aucune icône n’identifie le type du message. title est un argument nommé de type String
facultatif, affiché dans la barre de titre de la boîte de dialogue. Si cet argument est omis, c’est le
nom de l’application qui apparaît.
L’argument buttons est défini par la somme des valeurs choisies pour chacun des groupes présentés
dans le tableau 7-3. Votre code gagnera cependant en lisibilité si vous utilisez les constantes VBA
intégrées plutôt que des valeurs numériques.
Contrôler les programmes VBA
Chapitre 7
207
Si vous souhaitez, par exemple, afficher une boîte de dialogue contenant le symbole « Question »,
dans laquelle l’utilisateur pourra répondre par « Oui » ou « Non », l’argument buttons sera égal
à 36 : 4 (pour les boutons) + 32 (pour le symbole). Les trois instructions suivantes sont équivalentes
et entraînent l’affichage de la boîte de dialogue représentée à la figure 7-16. La troisième formule
est cependant plus compréhensible.
réponse = MsgBox("Autre recherche ?", 36, "Recherche")
réponse = MsgBox("Autre recherche ?", 32 + 4, "Recherche")
réponse = MsgBox("Autre recherche ?", vbYesNo + vbQuestion, "Recherche")
Astuce
Lorsque vous insérez la fonction MsgBox dans une procédure, placez le curseur sur la fonction, puis tapez
sur la touche F1 afin d’en activer la rubrique d’aide. Vous pourrez ainsi consulter le tableau répertoriant les
constantes à attacher à l’argument buttons.
Si vous souhaitez afficher une boîte de dialogue dans le seul objectif de transmettre une infor-
mation à l’utilisateur (ne comportant qu’un bouton OK), il est inutile d’affecter une variable à la
fonction MsgBox. Cependant, une fonction ne peut être utilisée que dans une instruction d’affec-
tation. Vous devez alors utiliser l’instruction MsgBox. Sa syntaxe est la même, à la différence près
que ses arguments ne sont pas encadrés par des parenthèses. L’instruction suivante affiche la boîte
de dialogue présentée à la figure 7-17.
MsgBox "Les documents sont en cours d'impression.", vbInformation
Par défaut, c’est le premier bouton qui est actif (celui qui sera validé si l’utilisateur appuie sur la
touche Entrée). Si une réponse positive de la part de l’utilisateur peut être lourde de conséquences,
il vaut mieux définir le deuxième ou le troisième comme bouton par défaut. L’instruction suivante
affiche la boîte de dialogue présentée à la figure 7-18 :
réponse = MsgBox("Supprimer toutes les informations ?", _
vbYesNoCancel + vbCritical + vbDefaultButton2)
La valeur renvoyée par la fonction MsgBox varie en fonction du bouton sur lequel l’utilisateur a
cliqué, selon la règle suivante :
Bouton Constante Valeur
OK vbOK 1
Annuler vbCancel 2
Abandonner vbAbort 3
Réessayer vbRetry 4
Ignorer vbIgnore 5
Oui vbYes 6
Non vbNo 7
Une instruction conditionnelle est utilisée pour tester la variable recevant l’information et orienter
le déroulement du programme en conséquence. Là encore, vous pouvez procéder en utilisant
la constante VBA ou la valeur numérique correspondante. Dans le cas de la boîte de dialogue
présentée à la figure 7-18, si l’utilisateur clique sur le bouton Oui, la valeur 6 (correspondant à la
constante vbYes) sera affectée à la variable réponse. S’il clique sur le bouton Non, la valeur 7 (vbNo)
sera retournée. Enfin, s’il choisit le bouton Annuler, c’est la valeur 2 (vbCancel) qui sera renvoyée.
Le programme suivant reprend l’exemple donné précédemment pour InputBox. Une fonction MsgBox
a été utilisée afin de proposer à l’utilisateur de définir une autre date, en cas de dépassement
d’échéance. S’il n’y a pas de dépassement d’échéance, une autre boîte de dialogue sera affichée
pour en informer l’utilisateur.
1: Sub VerifierEcheances()
2: Dim ZoneATester As String
3: ZoneATester = ActiveWindow.RangeSelection.Address
4: If ZoneATester=Null Then
5: MsgBox "Sélectionnez la plage de cellules à tester.", vbOKOnly + vbInformation
6: Exit Sub
7: End If
8: Dim DateEcheance As Variant
9: DateEcheance = InputBox("Indiquez la date d'échéance.", _
"Echéance des opérations en cours", Date + 30)
10: DateEcheance = CDate(DateEcheance)
Lignes 12 et 13, la variable DatesHorsEcheance – de type Boolean – est déclarée et se voit affecter
la valeur False. Ligne 18, une instruction lui affecte la valeur True si une date supérieure à celle
spécifiée par l’utilisateur est trouvée.
La mise en valeur des éventuelles cellules hors échéance terminée, une instruction condition-
nelle If…Then…Else est utilisée pour afficher un message (lignes 22 à 30). Si DateHorsEcheance
renvoie True (des cellules contenant des dates au-delà de celle spécifiée par l’utilisateur sont
trouvées), les instructions des lignes 23 à 28 sont exécutées. La boîte de dialogue représentée
à la figure 7-19 est alors affichée. La valeur renvoyée par la fonction MsgBox est stockée dans la
variable RedéfinirLaDate. Une structure conditionnelle imbriquée en teste ensuite la valeur. Si
elle renvoie vbYes (l’utilisateur a cliqué sur le bouton Oui), la couleur d’intérieur des cellules de
la zone sélectionnée est supprimée (ligne 26) et la fonction s’appelle elle-même (ligne 27). Si
DateHorsEcheance renvoie False, une boîte de dialogue s’affiche (ligne 29) afin d’informer l’utili-
sateur qu’il n’y a pas de problème.
Définition
Une procédure qui s’appelle elle-même est dite récursive.
Application.Dialogs(xlDialog).Show
Application.Dialogs(xlDialog).Display
Lorsqu’une boîte de dialogue Excel s’affiche à l’aide de la méthode Show, les commandes qu’elle
prend en charge s’exécutent normalement si l’utilisateur valide les paramètres qu’il y a définis. En
revanche, la méthode Display affiche la boîte de dialogue et permet de récupérer les informations
au moment de la validation par l’utilisateur, sans en exécuter les commandes. La procédure se
poursuit ensuite avec l’instruction située derrière celle qui a appelé la boîte de dialogue.
Vous pouvez évidemment affecter un objet Dialog à une variable de type Object ou Variant et
faire appel à cet objet pour afficher la boîte en question. Les instructions suivantes affichent la
boîte de dialogue Enregistrer sous.
Dim BoîteEnregistrerSous as Dialog
Set BoîteEnregistrerSous = Application.Dialogs(xlDialogSaveAs)
BoîteEnregistrerSous.Show
Vous trouverez une liste des constantes xlDialog dans l’aide de VBA pour Excel. Référez-vous à
la rubrique Références pour Microsoft Excel/Objets/Dialogs.
Attention
Contrairement à ce qui se passe lorsque vous appliquez la méthode Show à un objet Dialog, quand une
boîte de dialogue s’affiche à l’aide de GetOpenFilename ou GetSaveAsFilename, aucune action n’est
exécutée lorsque l’utilisateur clique sur le bouton de validation. Ces méthodes permettent simplement de
récupérer un nom de fichier. Ce fichier doit ensuite être manipulé par programmation.
Programmer en Visual Basic
212 Deuxième partie
Argument Description
InitialFilename Argument facultatif de type Variant. Nom de fichier par défaut apparaissant dans la zone de
texte Nom. Si cet argument est omis, le nom du classeur actif est utilisé par défaut.
FileFilter Argument facultatif de type Variant. Critères de filtrage des fichiers. Chaque critère doit
apparaître sous la forme d’une paire composée du filtre de fichier, suivi de la spécification de
son extension, tels qu’ils apparaissent dans la zone Type de fichier. Les paires sont également
séparées par des virgules. Si plusieurs extensions sont associées à un type de fichier, elles
doivent être séparées par un point-virgule. Par exemple, la valeur suivante :
"Classeur Microsoft Excel (*.xlsx),*.xlsx,PageWeb (*.htm; *.html), *.htm;*.
html"
définie pour l’argument FileFilter laissera apparaître deux types de fichiers.
FilterIndex Argument facultatif de type Variant. Index du critère de filtrage par défaut : 1 pour le premier,
2 pour le deuxième, etc.
Le premier filtre de fichier est utilisé si l’argument n’a pas été spécifié ou s’il est supérieur au
nombre de filtres disponibles.
Title Argument facultatif de type Variant. Texte apparaissant dans la barre de titre de la boîte de
dialogue. Si cet argument est omis, le titre de la boîte de dialogue est Ouvrir.
ButtonText Argument facultatif de type Variant. Sur Macintosh uniquement. Le libellé du bouton Ouvrir.
MultiSelect Argument facultatif de type Variant. Si MultiSelect a la valeur True, l’utilisateur peut
effectuer une sélection multiple. Si MultiSelect a la valeur False (valeur par défaut),
l’utilisateur ne peut sélectionner qu’un fichier.
Si plusieurs fichiers sont sélectionnés, la valeur est renvoyée sous forme de tableau et doit
donc être stockée dans une variable de type Variant ou Array.
Utilisez l’instruction ChDir pour modifier le dossier proposé par défaut dans la boîte de dialogue
affichée.
L’exemple suivant affiche la boîte de dialogue représentée à la figure 7-20, puis une boîte indiquant
la liste des fichiers choisis par l’utilisateur (voir figure 7-21).
1: Sub OuvertureDeFichiers()
2: Dim OuvrirFichiers As Variant
3: 'modification du chemin par défaut
4: ChDir ("C:\Users\Nom_utilisateur\Desktop\")
5: 'affichage de la boîte de dialogue Ouvrir
6: OuvrirFichiers = Application.GetOpenFilename(filefilter:="Classeur Microsoft
➥ Excel (*.xlsx),*.xlsx,PageWeb (*.htm; *.html),*.htm;*.html",
➥ filterindex:=2, Title:="Ouverture des fichiers ventes", MultiSelect:=True)
7: 'si l'utilisateur a sélectionné plusieurs fichiers
8: If UBound(OuvrirFichiers)>1 Then
9: Dim rep As Long
10: Dim Liste As String
Contrôler les programmes VBA
Chapitre 7
213
Figure 7-21 – Les fichiers sélectionnés sont récupérés dans une variable de matrice.
La variable OuvrirFichiers déclarée ligne 2 servira à stocker le(s) fichier(s) sélectionné(s) par
l’utilisateur. Ligne 4, le chemin par défaut est modifié à l’aide de l’instruction ChDir, pour que le
Bureau Windows soit proposé.
Ligne 6, la boîte de dialogue Ouvrir s’affiche. Le résultat de la sélection opérée par l’utilisateur
est affecté à la variable OuvrirFichiers. L’argument filefilter est défini pour que seuls les fichiers
portant l’extension .xlsx, .htm ou .html soient proposés. L’argument filterindex définit le deuxième
type de fichier (.htm ou .html) comme type par défaut. Enfin, le titre de la boîte de dialogue est
défini à Ouverture des fichiers ventes, et la sélection multiple est autorisée.
Ligne 8, une instruction conditionnelle If…Then…Else vérifie si plusieurs fichiers ont été sélection-
nés. Si tel est le cas, les instructions des lignes 8 à 26 s’exécutent.
Lignes 9 à 11, les variables rep, Liste et Compteur sont déclarées. Lignes 12 à 14, une instruction
For…Each…Next stocke la liste des fichiers sélectionnés dans la variable Liste. La valeur initiale du
compteur est 1 ; elle est incrémentée de 1 à chaque passage de la boucle jusqu’à atteindre la valeur
limite de la variable de matrice [UBound(OuvrirFichiers)]. À chaque passage, la variable Liste
reçoit sa valeur + un retour chariot (& vbCr) + la valeur stockée dans la variable OuvrirFichiers, à
la position correspondant à la valeur de Compteur [OuvrirFichiers(compteur)]. Lignes 16 à 18, une
instruction MsgBox est utilisée pour afficher la liste des fichiers sélectionnés par l’utilisateur et lui
proposer de les ouvrir (voir figure 7-21). Lignes 21 à 25, une instruction conditionnelle imbriquée
évalue la réponse de l’utilisateur. Une instruction For…Next ouvre les fichiers en cas de réponse
positive. Si un seul fichier a été sélectionné (ligne 27), il est ouvert (ligne 28).
Info
Si l’un des classeurs sélectionnés ne s’affiche pas, c’est qu’il est masqué. Utilisez la commande Afficher
de l’onglet Affichage du ruban.
Contrôler les programmes VBA
Chapitre 7
215
Tel qu’il se présente ici, ce programme générera une erreur si l’utilisateur clique sur le bouton
Annuler ou sur la croix de fermeture de la boîte de dialogue. Ajoutez les instructions qui suivent
entre les lignes 6 et 7 du programme précédent pour résoudre ce problème. Si aucun fichier n’est
sélectionné, le message de la figure 7-22 s’affiche et la procédure prend fin.
If OuvrirFichiers=False Then
MsgBox "Aucun fichier n'a été sélectionné. Fin de la procédure", _
VbOKOnly + vbCritical, "Fin de la procédure"
Exit Sub
End If
Les conditions établies à l’aide d’opérateurs logiques sont proches d’une condition exprimée dans
un langage courant, ce qui en facilite considérablement la compréhension.
Les instructions disponibles pour utiliser les opérateurs logiques sont présentées dans le tableau 7-5.
Opérateur Description
Or Contrôle que l’une des conditions spécifiées est vérifiée. Si c’est le cas, la condition renvoie True.
And Contrôle que toutes les conditions spécifiées sont vérifiées. Si c’est le cas, l’expression
conditionnelle renvoie True.
Xor Ou restrictif. Si l’une ou l’autre des conditions est respectée, l’expression conditionnelle renvoie
True. Si plus d’une condition est vérifiée, elle renvoie False.
Not Cet opérateur nie l’expression devant laquelle il est situé.
La structure conditionnelle If Not condition Then… est vérifiée si la condition n’est pas
respectée.
Programmer en Visual Basic
216 Deuxième partie
Astuce
Vous pouvez employer autant d’opérateurs Or et And que vous voulez dans une même expression. Cepen-
dant, pour les combiner, vous devez utiliser des parenthèses afin de spécifier quels sont les rapports entre-
tenus entre les différentes conditions. Vous obtiendrez alors des expressions du type :
If (Condition1 Or Condition2) And Condition3 Then
Série d'instructions
End If
Dans le cas d’une telle expression, la Série d’instructions ne sera exécutée que si l’une des deux premières
conditions (ou les deux) est vérifiée et si la Condition3 est aussi vérifiée.
La déclaration de notre fonction indique qu’elle attend la variable de tableau MaVar en argument.
Lignes 2 à 4, les variables sont déclarées. i et j sont les compteurs de nos boucles For…Next, tandis
que la variable temp servira simplement à stocker provisoirement des données.
Contrôler les programmes VBA
Chapitre 7
217
Lignes 5 à 13 se trouvent les boucles For…Next imbriquées, qui assurent le tri de notre tableau. La
boucle principale s’exécute autant de fois que la variable contient d’espaces de stockage – 1. Elle
trie la variable indice par indice, du premier au dernier.
La boucle imbriquée (lignes 6 à 12) effectue le tri à proprement parler. La valeur traitée est com-
parée à toutes les valeurs qui sont stockées après elle dans le tableau (j=i+1 To UBound(MaVar)).
Si la valeur traitée est supérieure à celle à laquelle elle est comparée (ligne 7), les deux sont
interverties (lignes 8 à 10). On stocke pour cela la valeur de mavar(i) dans la variable temp, puis
on lui substitue la valeur de mavar(j). On remplace ensuite la valeur de mavar(j) par la valeur de
mavar(i) précédemment mémorisée dans la variable temp.
Une fois la boucle imbriquée exécutée, la valeur stockée à l’indice i de notre variable est plus
petite que toutes celles qui la suivent. La structure For…Next principale reprend alors la main et
passe à l’indice suivant de la variable tableau. Une fois l’opération menée pour l’ensemble des
indices de la variable, les valeurs sont stockées par ordre croissant. Notre fonction reçoit alors la
valeur de MaVar (ligne 14) et prend fin, retournant la variable maintenant triée.
Astuce
Pour un tri décroissant, remplacez simplement le signe > de la ligne 7 par le signe <.
Dans l’exemple suivant, on utilise la même méthode de comparaison pour trier les feuilles de
travail du classeur actif. Cette fois-ci, les données ne sont pas stockées dans un tableau, mais les
feuilles sont directement triées sur le classeur.
1: Sub TriFeuilles()
2: Dim I As Integer
3: Dim J As Integer
4: Dim Min As Integer
5: Dim ModeCalcul As Integer
6: ModeCalcul = Application.Calculation
7: Application.Calculation = xlCalculationManual
8: Application.ScreenUpdating = False
9: With ActiveWorkbook.Worksheets
10: For I = 1 To .Count - 1
11: Min = I
12: For J = I + 1 To .Count
13: If .Item(J).Name<.Item(Min).Name Then Min = J
14: Next J
15: If Min<>I Then .Item(Min).Move before:=Worksheets(I)
16: Next I
17: End With
18: Application.Calculation = ModeCalcul
19: Application.ScreenUpdating = True
20: End Sub
Lignes 2 à 5, les variables sont déclarées. Ligne 6, la valeur Application.Calculation (le mode
de calcul défini pour le classeur) est mémorisée. Les lignes 7 et 8 sont destinées à optimiser le
temps d’exécution de la macro. Le classeur est ainsi passé en mode de calcul manuel ligne 7, afin
Programmer en Visual Basic
218 Deuxième partie
d’empêcher un éventuel recalcul des valeurs des cellules à chaque déplacement d’une feuille.
Ligne 8, la valeur False est affectée à la propriété ScreenUpdating de l’objet Application, afin de
ne pas mettre à jour l’affichage à l’écran lors de l’exécution de la macro.
Lignes 9 à 17, une structure With…End With est utilisée avec l’objet ActiveWorkbook.Worksheets
pour simplifier l’écriture du code. Lignes 10 à 16, deux boucles For…Next imbriquées assurent le
tri des feuilles.
La première boucle s’exécute autant de fois qu’il y a de feuilles dans le classeur – 1. À chaque
passage, la variable Min reçoit pour valeur l’index de la feuille en cours de traitement. La boucle
imbriquée (lignes 12 à 14) compare alors le nom stocké dans Min avec celui de chaque feuille
située après elle. Si un nom inférieur (alphabétiquement antérieur) est trouvé, Min reçoit pour
valeur l’index de la feuille portant ce nom.
À la fin de cette boucle, Min contient donc la valeur d’index de la feuille portant le nom le plus petit
parmi les valeurs qui ont été comparées. Ligne 15, on vérifie si on a trouvé une feuille portant un
nom plus petit lors des comparaisons (If Min<>I). Si c’est le cas, cette feuille est placée devant la
feuille en cours de traitement (.Item(Min).Move before:=Worksheets(I)).
La boucle principale reprend alors la main, et la feuille suivante est traitée selon le même prin-
cipe. Une fois les feuilles du classeur triées par ordre croissant de nom, le mode de calcul du
classeur est redéfini à son état initial (ligne 18), tandis que la mise à jour de l’affichage écran est
réactivée (ligne 19).
Conseil
Notez que, dans l’exemple précédent, on évite des opérations inutiles de déplacement de feuilles, en
mémorisant la donnée la plus petite lors des comparaisons (ligne 13) et en n’effectuant qu’une seule subs-
titution de position si nécessaire à la fin du passage de la boucle imbriquée (ligne 15). Exercez-vous à
modifier la fonction TriTableau présentée plus avant selon le même principe.
8
Fonctions Excel et VBA
Si les fonctions sont un élément clé du développement d’applications, quels que soient le langage
et l’environnement de programmation, c’est particulièrement vrai pour Excel, dont l’activité prin-
cipale consiste à effectuer des calculs.
Vos projets exploiteront aussi bien des fonctions d’Excel que de VBA, mais également celles que
vous allez créer.
Attention
Ne confondez pas les fonctions spécifiques à Excel et celles de Visual Basic. Si de nombreuses fonctions
mathématiques Excel ont leurs équivalents Visual Basic, le tableur en propose dans le domaine des statis-
tiques, de la finance, etc., qui lui sont propres et n’existent pas en Visual Basic. Un programme exploitant
ces fonctions ne pourra donc pas être exécuté dans une application hôte autre qu’Excel.
Pour utiliser une fonction Excel dans un programme VBA, vous ferez appel à l’objet Application
représentant l’application hôte (en l’occurrence Excel) qui la contient. Dans l’exemple suivant,
QuelEstLeMax exploite la fonction Max d’Excel, qui renvoie la valeur la plus forte dans une liste
d’arguments. Si vous ne faites pas précéder Max du mot-clé Application, la fonction ne sera pas
reconnue et une erreur sera générée.
Programmer en Visual Basic
220 Deuxième partie
Public Sub QuelEstLeMax()
MsgBox "Le plus grand des chiffres reçus est " _
& Application.Max(1,2,3,4), vbInformation + vbOKOnly, _
"Utiliser les fonctions Excel dans VB"
End Sub
Cette fonction calcule la cotisation perçue sur les droits d’auteur par l’AGESSA : une base de
95 % du salaire brut, au taux de 0,85 %.
Retournez dans Excel. Choisissez la commande Insérer une fonction du menu Formule et sélec-
tionnez la catégorie Personnalisées. La fonction apparaît dans la liste Sélectionnez une fonction,
précédée du nom du classeur dans lequel elle est stockée. Les arguments sont aussi visibles (voir
figure 8-1).
Figure 8-1 – Les fonctions créées dans Visual Basic Editor peuvent être exploitées dans Excel,
comme des fonctions intégrées.
Fonctions Excel et VBA
Chapitre 8
221
Les fonctions créées dans Visual Basic Editor sont gérées dans Excel comme n’importe quelle
fonction intégrée du tableur. Si vous cliquez sur le bouton OK de la boîte de dialogue Insérer
une fonction, vous serez invité à préciser les cellules correspondant aux arguments de la fonction
(voir figure 8-2). La fonction apparaîtra ensuite dans la barre de formule.
Figure 8-2 – Vous êtes invité à spécifier les cellules correspondant aux arguments de la fonction.
Conseil
Affectez des noms représentatifs aux arguments des fonctions que vous créez, afin qu’ils soient compré-
hensibles pour les autres utilisateurs.
5. Cliquez ensuite sur le bouton Copier dans le Presse-papiers, puis fermez l’Explorateur d’objets.
6. Dans la fenêtre Code, placez le curseur à l’endroit souhaité, puis tapez le raccourci Ctrl+V afin
de coller la fonction. Lorsque vous saisissez un espace, la liste des arguments attendus s’affiche.
Astuce
Sans passer par l’Explorateur d’objets, vous pouvez simplement saisir Application.WorksheetFunction
dans votre code pour faire apparaître la liste des fonctions disponibles.
Notez que vous pouvez omettre la propriété WorksheetFunction et vous contenter de faire précéder la
fonction de la propriété Application. Le code fonctionnera également, mais VBA n’affichera pas d’aide à
l’écriture lors de la saisie dans la fenêtre Code.
Notre fonction reçoit les arguments de type Currency CA (pour chiffre d’affaires) et Couts. La
première instruction de la fonction la déclare comme volatile. La fonction calcule ensuite le taux
de bénéfice réalisé en pourcentage.
Principales fonctions VBA
Cette section présente les fonctions de calcul VBA les plus couramment utilisées dans le cadre
de la programmation Excel. Elles sont classées selon les catégories suivantes :
• mathématiques ;
• conversion de données ;
• conversion de types de données ;
• date et heure ;
• fonctions financières.
Pour obtenir une aide plus développée concernant leur utilisation, consultez l’aide en ligne de VBA.
Info
Notez que les arguments des fonctions présentées dans les tableaux suivants sont pour la plupart des
arguments nommés. Lorsque ce n’est pas le cas, le nom est traduit en français.
Fonctions Excel et VBA
Chapitre 8
225
Dans le tableau 8-1, l’argument nommé Number représente une valeur numérique passée en
argument.
Type de données
Fonction Description
renvoyé
Abs(Number) Retourne la valeur absolue de Number. Même type que Number
Atn(Number) Retourne l’arctangente de Number, sous la forme d’un angle Double
exprimé en radians.
Pour convertir des degrés en radians, multipliez-les par
pi/180. Inversement, pour convertir des radians en degrés,
multipliez-les par 180/pi.
Cos(Number) Retourne le cosinus de l’angle Number (exprimé en radians). Double
Exp(Number) Retourne la valeur de la constante e élevée à la puissance Double
Number.
La constante e est la base des logarithmes népériens ; elle
est à peu près égale à 2,718282.
Fix(Number) Renvoie la partie entière d’un nombre. Même type que Number
Si Number est négatif, Fix renvoie le premier entier négatif
supérieur ou égal à Number.
Int(Number) Comme Fix, Int renvoie la partie entière d’un nombre, à la Même type que Number
différence que, si Number est négatif, Int renvoie le premier
entier négatif inférieur ou égal à Number.
Log(Number) Retourne le logarithme népérien de Number. Double
Rnd(Number) Retourne une valeur aléatoire. L’argument Number est Single
facultatif et définit le comportement de la fonction Rnd.
Notez que Rnd génère la même série de nombres aléatoires
à chaque appel, car elle réutilise le nombre aléatoire
précédent comme valeur initiale pour le calcul du nombre
suivant.
Utilisez l’instruction Randomize pour initialiser le générateur
de nombres aléatoires à partir d’une valeur initiale tirée de
l’horloge système.
Round(Number, Retourne la valeur arrondie de Number. Même type que Number
NumDigitsAfterDecimal) L’argument facultatif NumDigitsAfterDecimal indique le
nombre de chiffres à conserver après la virgule dans le
nombre retourné. Si cet argument est omis, Round renvoie la
valeur entière arrondie.
Sgn(Number) Retourne une valeur représentant le signe de Number : Integer
–1 si Number est inférieur à zéro ;
0 si Number est égal à zéro ;
1 si Number est supérieur à zéro.
Sin(Number) Retourne le sinus de l’angle Number exprimé en radians. Double
Sqr(Number) Retourne la racine carrée de Number. Double
Tan(Number) Retourne la valeur de la tangente de l’angle Number Double
exprimée en radians.
Programmer en Visual Basic
226 Deuxième partie
Le tableau 8-2 présente les fonctions de conversion de données de VBA. Elles traitent la valeur
reçue en argument et renvoient le résultat de ce traitement.
Les fonctions de conversion de types de données sont présentées dans le tableau 8-2.
Type de données
Fonction Description
renvoyé
Asc(String) Renvoie une valeur représentant le code du premier caractère Integer
de la chaîne de caractères String.
Chr(CharCode) Renvoie le caractère dont le code est CharCode, de type Integer
Long.
Format(Expression, Renvoie Expression sous forme de chaîne formatée selon le String
Format) Format défini.
Vous pouvez ainsi définir le format d’une date, ou modifier une
chaîne pour afficher le symbole de la monnaie et placer des
séparateurs entre les milliers.
Hex(Number) Retourne la valeur hexadécimale de Number sous forme de String
chaîne. Si Number n’est pas un nombre entier, il est arrondi à
l’entier le plus proche.
Oct(Number) Retourne la valeur octale de Number sous forme de chaîne. String
RGB(Red, Green, Blue) Retourne un entier représentant la couleur. Les arguments Long
Red, Green et Blue sont de type Integer et correspondent
chacun à la valeur de la couleur associée (rouge, vert, bleu),
comprise entre 0 et 255.
Str(Number) Renvoie Number sous forme de chaîne de caractères. Number String
peut être n’importe quelle valeur numérique que l’on souhaite
traiter comme une chaîne.
Val(String) Retourne String sous forme de valeur numérique de Type approprié à la
type approprié. Si String ne peut être converti en valeur valeur retournée
numérique, une erreur est générée.
Reportez-vous au tableau 6-5 pour un aperçu des fonctions de conversion de données. Ces fonctions
permettent de modifier le type d’une donnée. La conversion de données dans le type approprié
est souvent nécessaire au bon déroulement d’un programme VBA. Par exemple, tenter d’exécuter
une fonction mathématique sur une chaîne de caractères (même si celle-ci n’est composée que de
chiffres) générera une erreur. Vous devrez alors faire appel à la fonction de conversion numérique
appropriée afin que l’argument passé à la fonction soit reconnu comme une valeur et non plus
comme une suite de caractères.
Le tableau 8-3 présente les fonctions de date et d’heure. L’argument nommé date désigne toute
expression valide qui renvoie une valeur de type Date.
Fonctions Excel et VBA
Chapitre 8
227
Type de données
Fonction Description
renvoyé
Date Retourne la date en cours à partir de l’horloge système de votre Date
ordinateur. Utilisez l’instruction Date pour redéfinir la date de l’horloge
système.
Time Retourne l’heure en cours à partir de l’horloge système. Utilisez Date
l’instruction Time pour redéfinir l’heure système.
Now Retourne la date et l’heure en cours. Date
Year(Date) Retourne l’année correspondant à Date sous la forme d’un nombre Integer
entier.
Month(Date) Retourne le mois correspondant à Date sous la forme d’un entier Integer
compris entre 1 (janvier) et 12 (décembre).
Day(Date) Retourne le jour correspondant à Date sous la forme d’un nombre Integer
entier compris entre 1 et 31.
Weekday(Date, Retourne un entier compris entre 1 et 7, qui représente le jour de la Integer
FirstDayOfWeek) semaine correspondant à Date.
FirstDayOfWeek définit le jour considéré comme le premier de la
semaine. Il peut s’agir d’une valeur comprise entre 0 et 7, ou de
l’une des huit constantes vbDayOfWeek : vbUseSystem, vbMonday,
vbTuesday, vbWednesday, vbThursday, vbFriday, vbSaturday et
vbSunday.
Si l’argument FirstDayOfWeek est omis, la valeur par défaut est
vbUseSystem et dépend donc du système sur lequel est exécutée
la macro. En France, le premier jour de la semaine par défaut est
le lundi, tandis qu’aux États-Unis il s’agira du dimanche. Il est donc
recommandé de préciser l’argument FirstDayOfWeek afin d’éviter des
différences de comportements du programme d’un ordinateur à l’autre.
WeekdayName Retourne une chaîne qui représente le nom du jour de la semaine String
(WeekDay, WeekDay. WeekDay peut être un nombre compris entre 0 et 7, ou l’une
Abbreviate, des constantes vbDayOfWeek présentées ci-avant. La valeur retournée
FirstDayOfWeek) est renvoyée dans la langue du système sur lequel est exécutée la
fonction.
L’argument nommé Abbreviate est facultatif et définit si le jour est
renvoyé sous une forme abrégée (lun. pour lundi). Sa valeur par défaut
est False.
FirstDayOfWeek définit quel jour est considéré comme le premier de
la semaine.
Notez que la fonction Weekday peut être utilisée comme argument de
WeekdayName :
… WeekDayName(WeekDay(Date))
Hour(Date) Retourne un entier compris entre 0 et 23, qui représente les heures de Integer
Date. Si Date ne fournit pas d’information d’heure, la fonction renvoie 0.
Minute(Date) Retourne un entier compris entre 0 et 59, qui représente les minutes de Integer
Date. Si Date ne fournit pas d’information sur les minutes, la fonction
renvoie 0.
Second(Date) Retourne un entier compris entre 0 et 59, qui représente les secondes Integer
de Date. Si Date ne fournit pas d’information sur les secondes, la
fonction renvoie 0.
Programmer en Visual Basic
228 Deuxième partie
Type de données
Fonction Description
renvoyé
DateSerial(Year, Retourne une date précise (jour, mois et année), fonction des Date
Month, Day) arguments Year, Month et Day reçus.
TimeSerial(Hour, Retourne une heure précise (heures, minutes et secondes), en fonction Date
Minute, Second) des arguments reçus.
DateValue(Date) Renvoie la date reçue en argument. L’argument Date peut être une Date
chaîne de caractères, un nombre, une constante ou n’importe quelle
expression renvoyant une date.
TimeValue(Date) Renvoie l’heure reçue en argument. L’argument Date peut être une Date
chaîne de caractères, un nombre, une constante ou n’importe quelle
expression renvoyant une heure.
Timer Renvoie le nombre de secondes écoulées depuis minuit (d’après Single
l’horloge système de votre ordinateur).
Type de données
Fonction Description
renvoyé
Fonctions de calcul d’amortissement
DDB(Cost, Retourne la valeur de l’amortissement d’un bien au cours d’une période Double
Salvage, Life, définie, en utilisant la méthode d’amortissement dégressif à taux double
Period,) ou toute autre méthode précisée. Les arguments nommés reçus sont :
– Cost : coût initial du bien.
– Salvage : valeur du bien à la fin de son cycle de vie.
– Life : durée du cycle de vie du bien.
– Period : période sur laquelle l’amortissement du bien est calculé.
– Factor : facultatif. Taux utilisé pour le calcul de l’amortissement. Si
Factor est omis, la valeur 2 est employée (méthode d’amortissement
dégressif à taux double).
SLN(Cost, Retourne l’amortissement linéaire d’un bien sur une période définie. Double
Salvage, Life) Les arguments nommés sont les mêmes que pour la fonction DDB().
SYD(Cost, Retourne la valeur de l’amortissement global d’un bien sur une période Double
Salvage, Life, donnée.
Period) Les arguments nommés sont les mêmes que pour la fonction DDB().
Fonctions de calcul de valeur future
FV(Rate, NPer, Retourne le futur montant d’une annuité basée sur des versements Double
Pmt, PV, Type) constants et périodiques et sur un taux d’intérêt fixe. Les arguments
nommés reçus sont :
– Rate : taux d’intérêt par échéance. Pour un prêt dont le taux annuel
serait de 5 %, avec des échéances mensuelles, le taux par échéance
serait de 0,05/12, soit 0,0042 ;
– NPer : nombre d’échéances de l’emprunt ou du placement ;
– Pmt : montant du paiement à effectuer à chaque échéance ;
– PV : facultatif. Valeur actuelle (ou somme globale) d’une série de
paiements devant être effectués dans le futur. La valeur par défaut est 0 ;
– Type : facultatif. Date d’échéance des paiements. Indiquez 0 si les
paiements sont dus à terme échu, ou 1 si les paiements sont dus à
terme à échoir. Si l’argument est omis, la valeur par défaut est 0.
Fonctions Excel et VBA
Chapitre 8
229
Type de données
Fonction Description
renvoyé
Fonctions de calcul de taux d’intérêt
Rate(NPer, Pmt, Retourne le taux d’intérêt par échéance pour une annuité. Double
PV, FV, Type, Les arguments nommés NPer, Pmt, PV et Type sont les mêmes que pour
Guess) la fonction FV().
– FV : facultatif. Valeur future ou solde que vous souhaitez obtenir après
avoir effectué le dernier paiement. Si vous souhaitez épargner 10 000 ‡,
la valeur future est de 10 000. Si l’argument est omis, la valeur par
défaut est 0 (qui est la valeur future d’un emprunt).
– Guess : facultatif. Valeur qui devrait être renvoyée par la fonction Rate.
S’il est omis, Guess prend la valeur 0,1 (10 pour cent).
Fonctions de calcul de taux de rendement interne
IRR(Values(), Retourne le taux de rendement interne d’une série de mouvements Double
Guess) périodiques de trésorerie (paiements et encaissements). Les arguments
nommés sont les suivants :
– Values() : tableau de données indiquant les valeurs des mouvements
de trésorerie. Le tableau doit contenir au moins une valeur négative (un
paiement) et une valeur positive (un encaissement) ;
– Guess : facultatif. Valeur qui devrait être renvoyée par la
fonction IRR(). S’il est omis, Guess prend pour valeur 0,1 (10 pour cent).
MIRR(Values(), Retourne le taux de rendement interne modifié d’une série de Double
Finance_Rate, mouvements périodiques de trésorerie (paiements et encaissements) :
Reinvest_Rate) – Values() : idem que pour la fonction IRR() ;
– Finance_Rate : taux d’intérêt payé pour couvrir le coût du
financement ;
– Reinvest_Rate : taux d’intérêt perçu sur les gains tirés des sommes
réinvesties.
Fonctions de calcul de nombre d’échéances
NPer(Rate, Pmt, Retourne le nombre d’échéances d’une annuité basée sur des Double
PV, FV, Type) versements constants et périodiques et sur un taux d’intérêt fixe.
Les arguments nommés sont les mêmes que pour les fonctions FV() et
Rate().
Fonctions de calcul de montant de versements
IPmt(Rate, per, Renvoie une valeur indiquant le montant, sur une période donnée, d’une Double
NPer, PV, FV, annuité basée sur des versements constants et périodiques et sur un
Type) taux d’intérêt fixe.
Les arguments nommés sont les mêmes que pour les fonctions FV() et
Rate().
Pmt(Rate, NPer, Retourne le montant d’une annuité basée sur des versements constants Double
PV, FV, Type) et périodiques et sur un taux d’intérêt fixe.
Les arguments nommés sont les mêmes que pour les fonctions FV() et
Rate().
PPmt(Rate, per, Retourne la valeur du remboursement du capital, pour une échéance Double
NPer, PV, FV, donnée, d’une annuité basée sur des versements constants et
Type) périodiques, et sur un taux d’intérêt fixe.
Les arguments nommés sont les mêmes que pour les fonctions FV() et
Rate().
Programmer en Visual Basic
230 Deuxième partie
Type de données
Fonction Description
renvoyé
Fonctions de calcul de montant de valeur actuelle
NPV(Rate, Retourne la valeur nette actuelle d’un investissement, calculée Double
Values()) en fonction d’une série de mouvements périodiques de trésorerie
(paiements et encaissements) et d’un taux d’escompte. Les arguments
nommés sont les suivants :
– Rate : taux d’escompte sur la période, exprimé sous la forme d’un
nombre décimal ;
– Values() : tableau de données indiquant les valeurs des
mouvements de trésorerie. Le tableau doit contenir au moins une valeur
négative (un paiement) et une valeur positive (un encaissement).
PV(Rate, NPer, Retourne le montant actuel d’une annuité basée sur des échéances Double
Pmt, FV, Type) futures constantes et périodiques, et sur un taux d’intérêt fixe.
Les arguments nommés sont les mêmes que pour les fonctions FV() et
Rate().
9
Manipuler des chaînes
de caractères
La manipulation de chaînes de caractères est un aspect clé de la programmation, quel que soit le
langage, notamment pour informer et interagir avec l’utilisateur. Dans ce cadre, les valeurs numé-
riques doivent souvent être traitées et formatées comme des chaînes de caractères afin d’en extraire
les informations pertinentes. Par ailleurs, les informations retournées par la fonction InputBox
ou via un contrôle TextBox sont des chaînes de caractères et devront être traitées comme telles.
Toute expression qui renvoie une chaîne de caractères est utilisable : variable de type String,
fonction renvoyant une chaîne, chaîne de caractères entourée de guillemets. Si vous souhaitez
inclure une valeur numérique dans une chaîne, utilisez la fonction Str() pour la convertir
Considérez l’exemple suivant :
1: Sub ConcatenerDesChaînes()
2: Dim MonNom As String
3: Dim MonBenefice As Long
4: Dim MonMessage As String
5: MonNom = ActiveWorkbook.ActiveSheet.Cells(1,2).Value
6: MonBenefice = ActiveWorkbook.ActiveSheet.Cells(1,3).Value
7: MonMessage = "La prime de " & MonNom & " est de " & Str(Int(MonBenefice/20))
➥ & " euros."
8: MsgBox MonMessage
9: End Sub
Lignes 2 à 4, les variables sont déclarées. Notez que MonBenefice est de type Long et ne peut donc
être concaténée telle quelle. Lignes 5 et 6, MonNom et MonBenefice reçoivent respectivement pour
valeur le contenu des cellules B1 et C1.
Ligne 7 a lieu la concaténation des différentes chaînes de façon à générer le message affiché par
la fonction MsgBox à la ligne suivante.
Les éléments concaténés sont les suivants :
• "La prime de " est une simple chaîne de caractères, entourée de guillemets.
• MonNom est une variable de type String et peut donc être concaténée sans qu’il soit nécessaire
d’effectuer une conversion de type de données.
• " est de " est une simple chaîne de caractères. Notez que nous avons fait précéder et suivre
le texte d’espaces, pour que la chaîne finale soit lisible.
• Str(Int(MonBenefice/20)) est une expression renvoyant une chaîne de caractères. Tout d’abord,
la valeur numérique MonBenefice est divisée par 20, de façon à obtenir la valeur de la prime
(5 % du bénéfice). La fonction Int renvoie la valeur entière de la somme ainsi obtenue. Enfin,
la fonction Str convertit le résultat numérique ainsi obtenu en une chaîne de caractères.
• " euros" est une simple chaîne de caractères.
On obtient ainsi le message affiché dans la boîte de dialogue de la figure 9-1.
Delimiter (facultatif) définit la chaîne de caractères qui sera utilisée comme séparateur entre
les différentes données extraites de la SourceArray. S’il est omis, les éléments du tableau sont
concaténés sans séparateur.
Dans l’exemple suivant, les jours de la semaine sont stockés dans le tableau JoursSemaine. La boîte
de dialogue représentée à la figure 9-2 est ensuite affichée. Notez qu’on utilise une virgule suivie
d’un espace comme séparateur et que l’on ajoute un point à la fin de la chaîne.
Sub ConcatenerUnTableau()
Dim JoursSemaine(1 To 7)
Dim n as Byte
For n = 1 To 7
JoursSemaine(n) = WeekdayName(Weekday:=n, abbreviate:=False, _
FirstDayOfWeek:=vbMonday)
Next n
MsgBox "Les jours de la semaine sont : " & Join(JoursSemaine, ", ") & "."
End Sub
Figure 9-2 – Utilisez la fonction Join pour concaténer les espaces de stockage d’un tableau.
Dans l’exemple suivant, on insère un retour chariot, Chr(13), et une puce, Chr(149), devant chaque
jour de la semaine, afin de générer le message ensuite affiché dans une boîte de dialogue (voir
figure 9-3).
Sub UtiliserChr()
Programmer en Visual Basic
234 Deuxième partie
Dim n As Byte
Dim Message As String
Message = "Les jours de la semaine sont :"
For n = 1 To 7
Message = Message & Chr(13) & Chr(149) & " " & WeekdayName(Weekday:=n,
➥ abbreviate:=False, FirstDayOfWeek:=vbMonday)
Next n
MsgBox Message
End Sub
Figure 9-3 – Utilisez la fonction Chr() pour insérer des caractères non accessibles au clavier.
Afin d’améliorer la lisibilité de votre code, préférez les constantes Visual Basic à la fonction Chr()
quand cela est possible. Le tableau 9-1 présente les plus communément employées pour retourner
des caractères non imprimables, tels qu’un saut de pargraphe ou un retour à la ligne.
Astuce
Vous pouvez utiliser la fonction Chr() pour l’argument Character. Ainsi String(10,Chr(149)) renvoie
une chaîne composée de dix puces.
De façon similaire, la fonction Space renvoie une chaîne composée d’un nombre défini d’espaces,
selon la syntaxe suivante :
Space(Number)
• Left(String, Length) retourne les Length premiers caractères de String. Si Length est supérieur
ou égal à la longueur de String, la totalité de la chaîne est retournée.
• Right(String, Length) retourne les Length derniers caractères de String. Si Length est supérieur
ou égal à la longueur de String, la totalité de la chaîne est retournée.
• Mid(String, Start, Length) retourne Length caractères de String à partir de celui (inclus) de
la position Start. Si l’argument Length (facultatif) est omis ou s’il est trop grand, la fonction
renvoie tous les caractères de Start jusqu’à la fin de String.
Considérez les trois instructions suivantes :
1: MonTexte = Left(MonTexte, Len(MonTexte) - 1)
2: MonTexte = Right(MonTexte, Len(MonTexte) - 1)
3: Trim(Mid(ActiveWorkbook.ActiveSheet.Range("A1").Value, InStr(ActiveWorkbook.
➥ ActiveSheet.Range("A1").Value, Chr(34)) + 1))
La première instruction modifie la variable MonTexte en supprimant son dernier caractère. Ligne 2,
on supprime le premier caractère de MonTexte.
Enfin, l’instruction de la ligne 3 retourne le contenu de la cellule A1 à partir du premier guillemet
(non inclus) présent dans la chaîne. On utilise pour cela la fonction InStr() présentée plus loin
dans ce chapitre, qui retourne la position du caractère recherché (ici Chr(34), soit un guillemet).
On ajoute 1 à cette valeur pour commencer la chaîne à partir du caractère qui suit le guillemet.
Notez que l’on emploie la fonction Trim() afin de supprimer les éventuels espaces présents aux
extrémités de la chaîne retournée par la fonction Mid().
Expression est une expression valide qui renvoie la chaîne de caractères à traiter. Find est la chaîne
recherchée et à remplacer par Replace. Les trois arguments suivants sont facultatifs :
• Start précise la position à partir de laquelle doivent commencent les remplacements dans
Expression. Si cet argument est omis, l’ensemble de la chaîne est traité.
• Count indique le nombre de remplacements à effectuer. S’il est omis, sa valeur par défaut –1
est utilisée et toutes les occurrences de Find sont remplacées.
• Enfin, Compare précise le type de comparaison effectuée. Il peut s’agir de l’une des valeurs
suivantes :
– vbUseCompareOption ou –1. C’est la valeur de l’option Option Compare précisée dans l’en-
tête du module dans lequel se trouve l’instruction qui est utilisée pour définir le type de
comparaison.
– vbBinaryCompare ou 0. Effectue une comparaison binaire. La recherche respecte la casse
de Find.
Manipuler des chaînes de caractères
Chapitre 9
237
• vbTextCompare ou 1. Effectue une comparaison de texte. La recherche ne prend pas en consi-
dération la casse des occurrences trouvées.
• vbDatabaseCompare ou 2. Effectue une comparaison s’appuyant sur des informations contenues
dans une base de données Microsoft Access.
Dans l’exemple suivant, lignes 7 à 9, les données de la feuille active sont stockées dans le tableau
MesValeurs, tout en remplaçant au passage les « ; » par des « , ».
1: Sub UtiliserReplace()
2: Dim MaCellule As Range
3: Dim n As Long
4: Dim MesValeurs()
5: ReDim MesValeurs(1 To ActiveWorkbook.ActiveSheet.UsedRange.Cells.Count)
6: n = 0
7: For Each MaCellule In ActiveWorkbook.ActiveSheet.UsedRange.Cells
8: n = n + 1
9: MesValeurs(n) = Replace(MaCellule.Value, ";", ",")
10: Next MaCellule
11: End Sub
Astuce
Affectez une chaîne nulle à l’argument Replace pour supprimer toutes les occurrences de Find dans la
chaîne traitée.
L’argument facultatif Compare définit le type de comparaison à effectuer (voir les explications
fournies pour la commande Replace) :
• vbUseCompareOption ou –1.
• vbBinaryCompare ou 0.
• vbTextCompare ou 1.
• vbDatabaseCompare ou 2.
La fonction StrComp() renvoie les valeurs suivantes :
• –1 : String1 est inférieure à String2.
• 0 : String1 est égale à String2.
• 1 : String1 est supérieure à String2.
• Null : String1 ou String2 est de type Null.
La fonction StrComp() compare les codes ANSI des caractères qui composent les chaînes, par
ordre de position. Lorsque deux caractères comparés ont des codes différents, le processus s’arrête
et la fonction renvoie la valeur correspondante. Sinon la fonction passe aux caractères suivants
des deux chaînes, etc.
Le tableau suivant présente quelques exemples de comparaisons de chaînes en mode de compa-
raison vbTextCompare :
String1 String2 Résultat de la comparaison
a A Les deux chaînes sont identiques.
abc AbC Les deux chaînes sont identiques.
ab ba String1 est inférieure à String2.
abc a String1 est supérieure à String2.
La procédure suivante fait appel à la fonction InputBox() pour afficher à deux reprises une boîte de
saisie dans laquelle l’utilisateur est invité à entrer une chaîne de caractères. Les deux chaînes sont
ensuite comparées et le résultat s’affiche dans une boîte de dialogue grâce à l’instruction MsgBox.
Manipuler des chaînes de caractères
Chapitre 9
239
1: Sub ComparerDesChaînes()
2: Dim MaChaîne1 As String
3: Dim MaChaîne2 As String
4: MaChaîne1 = InputBox("Veuillez entrer la valeur de la chaîne 1 :",
➥ "Comparaison de chaînes")
5: Do Until MaChaîne1<>""
6: MaChaîne1 = InputBox("Vous devez préciser une chaîne à comparer !" & _
7: vbCr & "Entrez une valeur pour la chaîne 1 :", "Comparaison de chaînes")
8: Loop
9: MaChaîne2 = InputBox("Veuillez entrer la valeur de la chaîne 2 :",
➥ "Comparaison de chaînes")
10: Do Until MaChaîne2<>""
11: MaChaîne2 = InputBox("Vous devez préciser une chaîne à comparer !" & _
12: vbCr & "Entrez une valeur pour la chaîne 2 :", "Comparaison de chaînes")
13: Loop
14: Select Case StrComp(MaChaîne1, MaChaîne2, vbTextCompare)
15: Case -1
16: MsgBox "La chaîne 1 est inférieure à la chaîne 2."
17: Case 0
18: MsgBox "La chaîne 1 et la chaîne 2 sont identiques."
19: Case 1
20: MsgBox "La chaîne 1 est supérieure à la chaîne 2."
21: End Select
22: End Sub
Lignes 5 à 8 pour la première chaîne et 10 à 13 pour la seconde, une structure Do Until…Loop
affiche de nouveau une boîte de saisie si l’utilisateur a validé avec une zone de saisie vide. On
utilise ici l’opérateur <> pour comparer deux chaînes (la variable et une chaîne vide) afin de définir
si la boucle doit être exécutée.
Lignes 14 à 21, une structure Select Case…End Select définit le message à afficher selon la valeur
renvoyée par l’instruction StrComp().
L’argument start est facultatif et indique la position du caractère à partir duquel commence la
recherche (le premier par défaut). L’argument facultatif compare définit le type de comparaison à
effectuer (voir les précisions fournies pour la commande Replace) :
• vbUseCompareOption ou –1.
• vbBinaryCompare ou 0.
• vbTextCompare ou 1.
• vbDatabaseCompare ou 2.
Dans l’exemple suivant, la procédure MaMacro appelle la fonction VerifierEnregistrement pour
s’assurer que le document actif est enregistré avant de s’exécuter. Si ce n’est pas le cas, la fonc-
tion renvoie False et l’instruction End met fin à l’exécution du programme après avoir affiché un
message à l’attention de l’utilisateur.
1: Sub MaMacro()
2: If VerifierEnregistrement(ActiveWorkbook)=False Then
3: MsgBox "Cette commande ne peut être exécutée que sur un fichier
➥ enregistré.", _
4: vbOKOnly + vbCritical, "Exécution impossible"
5: End
6: End If
7: 'suite des instructions de la macro
8: End Sub
Ligne 7, la fonction ScinderChaîne est appelée et reçoit en arguments la variable Exemple définie
à la ligne précédente, ainsi que le séparateur à utiliser, en l’occurrence deux-points.
La fonction ScinderChaîne prend alors la main. La variable de matrice mavar est déclarée puis
initialisée à la ligne suivante. Ligne 17, pos reçoit le résultat de la recherche du séparateur au
sein de la chaîne.
Lignes 18 à 23, une structure de contrôle Do While…Loop répète la recherche tant qu’elle aboutit,
c’est-à-dire tant que la fonction InStr() renvoie une valeur différente de 0. À chaque nouvelle
recherche, on affecte au dernier espace de stockage de mavar la chaîne précédant la position du
séparateur trouvé (Left(machaîne, pos–1)). machaîne est ensuite redéfinie de façon à en supprimer
la partie extraite, ainsi que le séparateur recherché (ligne 20), grâce aux fonctions Mid() et Len().
La comparaison est alors effectuée sur la nouvelle chaîne (ligne 21) et mavar reçoit un espace de
stockage supplémentaire. Notez l’utilisation du mot-clé Preserve pour conserver les valeurs déjà
stockées dans mavar.
Enfin, ligne 24, le dernier espace de stockage de mavar reçoit la valeur de machaîne quand la
recherche n’a pas abouti. La procédure appelante reprend alors la main et le message représenté
à la figure 9-4 s’affiche.
Programmer en Visual Basic
242 Deuxième partie
Figure 9-4 – La fonction InStr() peut servir à scinder une chaîne en fonction d’un séparateur.
où expression fournit la chaîne de caractères à scinder. Les trois autres arguments sont faculta-
tifs : delimiter est la chaîne de caractères utilisée comme séparateur (l’espace par défaut), limit
indique le nombre de chaînes à renvoyer (toutes par défaut) et compare a le même rôle que dans
la fonction Instr() présentée ci-avant.
Attention
Notez que le résultat retourné par la fonction Split() ne peut être stocké que dans une variable de type
Variant. Si vous tentez de le faire dans une variable tableau, une erreur est générée.
Ligne 3, la variable est maintenant déclarée de type Variant, pour recevoir le résultat retourné
par la fonction Split(). Ligne 7, la fonction Instr() précédemment employée dans la boucle est
remplacée par Split(). Ligne 8, la boucle démarre à zéro, car le tableau retourné par Split() est
de base zéro. Pour la même raison, ligne 11, nous avons ajouté 1 à UBound(MonResultat) afin de
retourner la taille de la variable MonResultat.
sourcearray représente la matrice à une dimension dans laquelle s’effectue la recherche et match
est la chaîne recherchée. include et compare sont facultatifs. Si include est défini à True (valeur
par défaut), les contenus des zones de stockage où a abouti la recherche sont retournés. Si include
est défini à False, ce sont les zones de stockage dans lesquelles n’a pas abouti la recherche qui
sont renvoyées.
Dans l’exemple suivant, on affecte les noms des jours de la semaine à une variable de matrice.
On effectue ensuite quatre recherches distinctes au sein de la variable et on en affiche les résultats.
1: Sub RechercherDansUnTableau()
2: Dim n As Long
3: Dim JoursSemaine(1 To 7)
4: Dim MaRecherche1
5: Dim MaRecherche2
6: Dim MaRecherche3
7: Dim MaRecherche4
8: Dim Message As String
9: For n = 1 To 7
10: JoursSemaine(n) = WeekdayName(Weekday:=n, abbreviate:=False,
➥ firstdayofweek:=vbMonday)
11: Next n
12: MaRecherche1 = Filter(sourcearray:=JoursSemaine(), match:="M", include:=True,
➥ Compare:=vbBinaryCompare)
13: MaRecherche2 = Filter(sourcearray:=JoursSemaine(), match:="M",
➥ include:=False, Compare:=vbBinaryCompare)
14: MaRecherche3 = Filter(sourcearray:=JoursSemaine(), match:="M", include:=True,
➥ Compare:=vbTextCompare)
15: MaRecherche4 = Filter(sourcearray:=JoursSemaine(), match:="M",
➥ include:=False, Compare:=vbTextCompare)
16: If Not UBound(MaRecherche1)=-1 Then
17: Message = "- Résultat de la recherche avec include:=True et
➥ Compare:=vbBinaryCompare :" & vbCr
18: For n = 0 To UBound(MaRecherche1)
19: Message = Message & " " & MaRecherche1(n) & " /"
Programmer en Visual Basic
244 Deuxième partie
20: Next n
21: Else
22: Message = "- Pas de résultat pour la recherche avec include:=True et
➥ Compare:=vbBinaryCompare."
23: End If
24: If Not UBound(MaRecherche2)=-1 Then
25: Message = Message & vbCr & "- Résultat de la recherche avec
➥ include:=False et Compare:=vbBinaryCompare " & vbCr
26: For n = 0 To UBound(MaRecherche2)
27: Message = Message & " " & MaRecherche2(n) & " / "
28: Next n
29: Else
30: Message = Message & vbCr & "- Pas de résultat pour la recherche avec
➥ include:=False et Compare:=vbBinaryCompare."
31: End If
32: If Not UBound(MaRecherche3)=-1 Then
33: Message = Message & vbCr & "- Résultat de la recherche avec include:=True
➥ et Compare:=vbTextCompare" & vbCr
34: For n = 0 To UBound(MaRecherche3)
35: Message = Message & " " & MaRecherche3(n) & " / "
36: Next n
37: Else
38: Message = Message & vbCr & "- Pas de résultat pour la recherche avec
➥ include:=True et Compare:=vbTextCompare."
39: End If
40: If Not UBound(MaRecherche4)=-1 Then
41: Message = Message & vbCr & "- Résultat de la recherche avec
➥ include:=False et Compare:=vbTextCompare : " & vbCr
42: For n = 0 To UBound(MaRecherche4)
43: Message = Message & " " & MaRecherche4(n) & " / "
44: Next n
45: Else
46: Message = Message & vbCr & "- Pas de résultat pour la recherche avec
➥ include:=False et Compare:=vbTextCompare."
47: End If
48: MsgBox Message
49: End Sub
Lignes 9 à 11, le nom des jours de la semaine est affecté aux sept espaces de stockage de la variable
JoursSemaine. On fait pour cela appel à la fonction WeekdayName() présentée au chapitre précédent.
Lignes 12 à 15, on recherche à quatre reprises la chaîne "M" dans la variable avec, chaque fois,
des valeurs différentes pour les arguments include et compare.
Les mêmes instructions sont ensuite appliquées aux quatre résultats de recherche, afin de créer le
message à afficher (lignes 16 à 23, 24 à 31, 32 à 39 et 40 à 47). On utilise pour cela une structure
If…Then…Else afin de savoir si la recherche a abouti. Si c’est le cas, une boucle For…Next est utilisée
pour concaténer les contenus du tableau ayant reçu le résultat de la fonction.
Enfin, on affiche le message représenté à la figure 9-5.
Manipuler des chaînes de caractères
Chapitre 9
245
La base de registre de Windows est une base de données où sont stockées des informations asso-
ciées au système d’exploitation et aux applications. Celles-ci permettent notamment de définir le
comportement des applications, de mémoriser les préférences de l’utilisateur, de lire et modifier
le numéro de la version d’un logiciel, etc. Le terme « clé » désigne une entrée dans la base de
registre à laquelle est affectée une « valeur ».
Figure 10.2 – Des informations concernant l’application Acrobat Reader DC dans la base de registre.
Dans ce chapitre, nous illustrons l’écriture et la lecture dans la base de registre, dans un pro-
gramme VBA, par l’utilisation de deux clés qui nous informeront sur la date d’installation du
programme et sur le type de version (évaluation ou abonnement). Celles-ci nous permettront de
nous assurer que la licence est valide. Si la licence n’est pas valide, l’utilisateur sera averti et la
procédure mettra fin à l’exécution de la commande en cours.
Dans un second temps, nous modifierons le programme afin de proposer à l’utilisateur une prolon-
gation de 15 jours de la période d’évaluation. Pour cela, il devra saisir un code qui lui sera envoyé
par e-mail. Vous récupérerez de cette façon l’adresse mail de l’utilisateur, que vous pourrez réu-
tiliser par la suite afin de pouvoir le relancer et lui faire d’éventuelles propositions commerciales.
Les deux fonctions VBA permettant d’accéder à la base de registre de Windows via le code de
vos programmes VBA sont :
• SaveSetting, qui permet de créer ou de modifier la valeur d’une clé (si la clé n’existe pas, elle
est créée) ;
• GetSetting, qui permet de récupérer la valeur d’une clé.
Les droits d’accès à la base de registre par programmation VBA sont limités : les clés que vous
pouvez créer et lire se trouvent obligatoirement dans le sous-dossier « VB and VBA Program
Settings », qui se trouve sous le dossier \HKEY_CURRENT_USER\SOFTWARE\.
Le dossier de la base de registre dans lequel seront créées vos clés par programmation VBA
sera ainsi toujours : Ordinateur\HKEY_CURRENT_USER\SOFTWARE\VB and VBA Program
Settings\
Figure 10.3 – Les droits de lecture et d’édition de la base de registre par programmation VBA
se limitent au dossier « VB and VBA Program Settings ».
Programmer en Visual Basic
250 Deuxième partie
Vous utiliserez l’instruction SaveSetting pour créer une clé dans la base de registre et lui affecter
une valeur. Si la clé n’existe pas, elle sera créée et la valeur précisée dans l’instruction lui sera
affectée. Si la clé existe déjà, la nouvelle valeur lui sera affectée. Si vous lui affectez une chaîne
vide (""), la valeur de la clé sera supprimée, mais la clé sera créée ou maintenue si elle existait déjà.
Utilisez l’instruction SaveSetting selon la syntaxe suivante :
SaveSetting appname, section, key, value
• Appname : chaîne de caractères qui contient le nom de l’application ou du projet concerné. C’est
ce nom qui sera affecté au sous-dossier qui sera placé immédiatement sous le dossier « VB and
VBA Program Settings ».
• Section : chaîne de caractères représentant le nom de la section dans laquelle la valeur de la
clé doit être enregistrée. Sur la figure 10.4, il s’agit de la section Licence.
• Key : chaîne de caractères contenant le nom de la clé qui sera créée ou modifiée.
• Value : valeur attribuée à la clé Key.
Écrire et lire dans la base de registre
Chapitre 10
251
L’instruction suivante :
SaveSetting "Articho", "Licence", "Langue", "EN"
crée le dossier /Articho/Licence/, et y crée la clé Langue à laquelle est affectée la valeur EN,
comme cela est représenté sur la figure suivante.
Figure 10.5 – Utilisez l’instruction SaveSetting pour créer et modifier des entrées dans la base de registre.
• Appname : chaîne de caractères qui contient le nom de l’application ou du projet concerné. Il peut
s’agir de n’importe quel nom. C’est ce nom qui sera affecté au sous-dossier qui sera placé
immédiatement sous le dossier « VB and VBA Program Settings ».
• Section : chaîne de caractères représentant le nom de la section dans laquelle la valeur de la
clé doit être enregistrée. Sur la figure 10.4, il s’agit de la section Licence.
• Key : chaîne de caractères contenant le nom de la clé qui sera lue.
• default : cet argument est facultatif. Il contient la valeur à renvoyer si aucune valeur n’est
affectée à la clé, ou si la clé n’existe pas. Dans les deux cas, la valeur renvoyée est une chaîne
vide ("") si cet argument n’est pas précisé.
Programmer en Visual Basic
252 Deuxième partie
Le programme ci-dessous interroge la valeur de la clé Langue et affecte cette valeur à une variable.
Si la clé n’existe pas ou que sa valeur est nulle, elle est créée et la valeur EN lui est affectée.
1: Public Sub DefinirDivLang()
2: DivLangue = GetSetting("Articho", "Licence", "Langue")
3: If DivLangue = "FR" Then
4: NomFichierDonnees = "data-fr.rtf"
5: ElseIf DivLangue = "EN" Then
6: NomFichierDonnees = "data-en.rtf"
7: ElseIf DivLangue = "" Then
8: SaveSetting "Articho", "Licence", "Langue", "EN"
9: DivLangue = "EN"
10: NomFichierDonnees = "data-en.rtf"
11: End If
12: End Sub
Ligne 2, la fonction GetSetting est utilisée afin de récupérer la valeur de la clé Langue, qui se
trouve dans la section Licence du dossier application Articho. Cette valeur est stockée dans la
variable DivLangue. Lignes 3 à 11, une structure de contrôle If…Then…Else est utilisée pour définir
la valeur de la variable NomFichierDonnees fonction de la valeur de la clé du registre : si la valeur
de la clé est "FR", le nom de fichier stocké dans la variable est data-fr.rtf, si la valeur est "EN",
le nom de fichier affecté à la variable sera data-en.rtf. Lignes 7 à 10, une dernière option est
considérée : si la valeur de la clé est une chaîne de caractères vide ou si la clé n’existe pas, alors
l’instruction de la ligne 8 affecte la valeur "EN" à la clé. Ligne 9, la variable DivLangue reçoit la
valeur "EN" qui est maintenant celle de la clé Langue de la base de registre et, logiquement, la
variable NomFichierDonnees reçoit la valeur "data-en.rtf".
de la licence. Vous n’avez donc pas à passer par un programme d’installation qui écrira ces
informations lors de son exécution, puisque cela aura lieu dès le premier appel de la procédure
VerifierLicence().
Info
La création d’un programme d’installation avec Inno Setup fait l’objet de l’annexe B. Notez qu’un pro-
gramme d’installation créé avec Inno Setup peut également écrire dans la base de registre.
• La date d’installation du programme. Si cette clé manque, elle sera créée et la date du jour
retournée par le système sera affectée à cette clé.
Dans sa première version, notre module est composé :
• des déclarations des variables qui seront utilisées pour stocker les informations récupérées
dans la base de registre et partagées par les différentes procédures. Celles-ci sont placées en
tête du module de code :
Option Explicit
Option Base 1
Public DateRegistre
Public DateDuJour
Public NbreJoursExpires
Public Abo As String
• de la procédure d’appel du contrôle de la licence. Celle-ci est composée d’une seule instruction
qui consiste en un simple appel à la procédure de vérification de licence. Cette instruction
pourra être placée au début de n’importe quelle procédure afin de contrôler la validité de la
licence avant d’exécuter une commande :
Sub MaProcedureInitiale()
Call VerifierLicence
End Sub
et
Sub LireRegistre()
La procédure utilise la fonction GetSetting en lignes 3 et 9 afin de lire les valeurs des clés Abo
et Date et de les mémoriser respectivement dans les variables Abo et DateRegistre. C’est la valeur
de ces variables que notre programme VerifierLicence() utilisera afin de laisser se dérouler le
programme si la licence est valide ou d’y mettre fin et d’afficher le message adéquat à l’attention
de l’utilisateur dans le cas contraire.
Lignes 4 à 7, si la valeur de la variable Abo (donc de la clé Abo puisque c’est cette valeur qui a
été affectée à la variable en ligne 3) est une chaîne vide (""), la valeur "eval" est affectée à la
variable (ligne 5), et celle-ci est écrite dans le registre grâce à la fonction SaveSetting (ligne 6).
Lignes 9 à 14, on fait de même pour lire la valeur de la clé Date dans la base de registre et écrire
la date du jour si cette clé n’est pas renseignée. On utilise pour cela les fonctions Format et Now :
la fonction Format permet de définir à "dd/mm/yyyy" le format de la date renvoyée par Now. La
fonction CStr de la ligne suivante convertit la date en chaîne de caractères, tandis que la fonction
Trim supprime les éventuels espaces en début ou en fin de chaîne de caractères.
Figure 10.6 – La procédure LireRegistre() écrit les clés dans la base de registre lors de sa première exécution.
1: Sub VerifierLicence()
2: 'On lit les valeurs de la base de registre
3: Call LireRegistre
4: 'Calcul du nombre de jours expirés entre la date du registre et la date
➥ du jour
5: DateDuJour = Format(Now, "dd/mm/yyyy")
6: NbreJoursExpires = DateDiff("d", DateRegistre, DateDuJour)
7: ''Si validité expirée
8: If NbreJoursExpires > 15 Then
9: MsgBox "Votre période d'évaluation est expirée depuis le
➥ "& Str(DateAdd("d", 15, DateRegistre)), vbOKOnly + vbCritical,
➥ "Période d'évaluation expirée"
10: End
11: 'En période de validité
12: Else
13: MsgBox "Votre période d'évaluation est valide jusqu'au "&
➥ (DateAdd("d", 15, DateRegistre)), vbOKOnly + vbInformation,
➥ "Période d'évaluation valide"
14: End If
15: End Sub
Nous commençons donc par appeler en ligne 3 la procédure LireRegistre précédemment créée.
Ligne 5, nous récupérons la date du jour, puis nous calculons le nombre de jours écoulés entre la
date du jour et la date inscrite dans la base de registre :
NbreJoursExpires = DateDiff ("d", DateRegistre, DateDuJour)
Programmer en Visual Basic
256 Deuxième partie
La fonction DateDiff renvoie le nombre d’intervalles de temps (dans notre cas "d", c’est-à-dire le
nombre de jours) entre deux dates et s’utilise selon la syntaxe suivante :
DateDiff(interval, date1, date2, [firstdayofweek, [firstweekofyear]])
Les trois arguments nommés non facultatifs et qui nous importent ici sont :
• interval, qui représente l’intervalle de temps que retournera la fonction. Ici, nous utilisons
la constante d (pour « day ») afin d’obtenir le nombre de jours qui séparent les deux dates ;
• les arguments date 1 et date 2 sont les deux dates qui seront comparées. La valeur retournée
par la fonction DateDiff sera positive si date 2 est une date ultérieure à date 1 et négative dans
le cas inverse.
Lignes 8 à 14 une structure conditionnelle If…Then…Else est utilisée pour déterminer le comporte-
ment du programme. Si le temps écoulé est supérieur à 15 jours, un message est affiché (ligne 9)
et la fonction End met fin à l’exécution en cours.
Si le nombre de jours écoulé entre les deux dates est inférieur à 15, un message (placé ici à titre
indicatif et que vous pouvez supprimer de la procédure) est affiché. La procédure de vérification
prend fin et la procédure qui a appelé la procédure VerifierLicence() reprend la main.
Nous créerons ensuite la fonction qui effectuera le cheminement inverse afin de récupérer la date à
partir de la chaîne ainsi obtenue. Cette fonction « rétro-convertira » ainsi la chaîne "BCACJAAC"
en "20/09/2021".
La procédure (de chiffrage) sera appelée lors de l’écriture dans la base de registre, et la procédure
de déchiffrage sera appelée lors de la lecture de la date dans la base de registre.
Commencez par supprimer l’entrée MonProg de la base de registre. Cliquez droit sur le dossier
MonProg dans l’éditeur de registre et choisissez Supprimer.
Cette fonction reçoit en argument madate qui est la chaîne de caractères qui sera chiffrée et dont
le résultat sera renvoyé par la fonction.
Ligne 6, la fonction Replace est utilisée pour supprimer le caractère slash de la chaîne de caractères
madate. Dans l’expression Replace(madate, "/", ""), les trois arguments correspondent respecti-
vement à la chaîne de caractères traitée (madate), au caractère recherché ("/") et le caractère de
remplacement qui est ici une chaîne vide ("").
Lignes 8 à 10, l’ordre des caractères contenus dans la variable nouvdate est inversé et stocké dans
la variable nouvdate2. On utilise pour cela une fonction For…Next avec un pas négatif de –1, qui va
du nombre de caractères de la chaîne reçue (Len(nouvdate)) à 1. À chaque passage, le caractère
est ajouté à la variable nouvdate2.
Lignes 12 à 35, une boucle For…Next parcourt un à un les caractères de la variable nouvdate2.
On utilise là encore la fonction Len() afin de retourner le nombre de caractères de la chaîne
n ouvdate2. À chaque passage, ligne 13, la fonction Mid() retourne le caractère voulu (Select Case
Mid(nouvdate2, n, 1)). Une structure Case…Select case (lignes 13 à 34) associe une lettre au chiffre
reçu : 0 = A, 1 = B, 2 = C…, 9 = J. La variable est ainsi réécrite. Enfin, ligne 36, la fonction reçoit
pour valeur la chaîne de caractères générée.
1: Function LicenceDecoderDate(madate)
2: Dim nouvdate As String
3: Dim n
4: 'On inverse l'ordre des caractères (BCACJAAC ->CAAJCACB)
5: For n = Len(madate) To 1 Step -1
6: nouvdate = nouvdate & Mid(madate, n, 1)
7: Next n
8: 'On remplace les lettres par des chiffres (CAAJCACB -> 20092021)
9: For n = 1 To Len(nouvdate)
10: Select Case Mid(nouvdate, n, 1)
11: Case Is = "A"
12: Mid(nouvdate, n, 1) = "0"
13: Case Is = "B"
14: Mid(nouvdate, n, 1) = "1"
15: Case Is = "C"
16: Mid(nouvdate, n, 1) = "2"
17: Case Is = "D"
18: Mid(nouvdate, n, 1) = "3"
19: Case Is = "E"
20: Mid(nouvdate, n, 1) = "4"
21: Case Is = "F"
22: Mid(nouvdate, n, 1) = "5"
23: Case Is = "G"
24: Mid(nouvdate, n, 1) = "6"
25: Case Is = "H"
26: Mid(nouvdate, n, 1) = "7"
27: Case Is = "I"
28: Mid(nouvdate, n, 1) = "8"
29: Case Is = "J"
30: Mid(nouvdate, n, 1) = "9"
31: End Select
32: Next n
33: 'On replace les signes / aux endroits opportuns (20092021 -> 20/09/2021)
34: nouvdate = Left(nouvdate, 2) & "/" & Mid(nouvdate, 3, 2) & "/" & Mid(nouvdate, 5)
35: LicenceDecoderDate = nouvdate
36: End Function
Lignes 5 à 7, les caractères de la chaîne reçue en argument sont inversés, c’est-à-dire que la chaîne
est réécrite de droite à gauche.
Lignes 9 à 32, on utilise, la même structure de contrôle For…Next que celle de la fonction
LicenceCoderDate pour parcourir tous les caractères de la variable nouvdate. À chaque passage,
une structure Case…Select Case remplace la lettre en question par un chiffre, à l’exact inverse de
la structure équivalente de la fonction LicenceCoderDate.
Enfin, ligne 34, les caractères slash ("/") sont insérés après les 2e et 4e caractères afin d’achever la
recomposition de la date. On utilise pour cela les fonctions Left et Mid qui permettent toutes les
deux de retourner une partie d’une chaîne de caractères, la fonction Left partant de la gauche de
la chaîne, tandis que la fonction Mid part du nième caractère de la chaîne reçue.
Programmer en Visual Basic
260 Deuxième partie
où string est la chaîne de caractères reçue et lenght le nombre de caractères renvoyé à partir
de la gauche de cette chaîne. Dans l’instruction de la ligne 34, ce sont donc les deux premiers
caractères qui sont retournés.
La syntaxe de la fonction Mid() est la suivante :
Mid(string, start, [length])
où string est la chaîne reçue et start une valeur représentant la position du caractère à partir
duquel se fait l’extraction. L’argument lenght est facultatif et représente le nombre de caractères
qui doit être extrait de la chaîne reçue. Si cet argument est omis, tous les caractères de la chaîne
string situés à droite de la position start sont retournés.
Enfin, ligne 35, la chaîne ainsi recomposée est affectée à la fonction.
Nous avons modifié l’instruction de la ligne 13 afin que la chaîne affectée à la clé dans la base
de registre soit d’abord codée, et nous avons ajouté une instruction Else en lignes 14 et 15 afin de
décoder la chaîne récupérée si celle-ci n’est pas vide et afin de récupérer la date.
Écrire et lire dans la base de registre
Chapitre 10
261
où interval est une chaîne de caractères représentant le type d’intervalle à ajouter – dans notre
cas, il s’agira d’un intervalle de type « jour » (d)–, number est le nombre d’intervalles à ajouter et
date la date à laquelle sont ajoutés ces intervalles.
Nous commencerons par créer la fonction de prolongation de la licence :
1: Sub ProlongerLicence()
2: DateRegistre = DateAdd("d", 15, DateRegistre)
3: SaveSetting "MonProg", "Licence", "Abo", "prol"
4: SaveSetting "MonProg", "Licence", "Date", LicenceCoderDate(DateRegistre)
5: End Sub
Ligne 2, nous ajoutons 15 jours à la date stockée dans la variable DateRegistre. La valeur de la
clé Abo est ensuite modifiée : nous lui affectons la chaîne "prol", qui indique que la licence est à
l’étape de prolongation. Cette information nous permettra de ne pas proposer de prolongation de
licence si cela a déjà été fait, c’est-à-dire si la valeur de la clé Abo n’est pas "eval".
Ligne 4, nous modifions la valeur de la clé Date à l’aide de l’instruction SaveSetting. L’appel à la
fonction LicenceCoderDate au sein de cette instruction chiffre la date avant de l’inscrire dans la
base de registre.
Modifiez maintenant le code de la procédure VerifierLicence() ainsi :
1: Sub VerifierLicence()
2: 'On lit les valeurs de la base de registre
3: Call LireRegistre
4: 'Calcul du nombre de jours expirés entre la date du registre et du jour
5: DateDuJour = Format(Now, "dd/mm/yyyy")
6: NbreJoursExpires = DateDiff("d", DateRegistre, DateDuJour)
7: 'Si validité expirée
8: If NbreJoursExpires > 15 Then
9: If Abo = “eval” And NbreJoursExpires < 30 Then
10: Dim rep
11: rep = MsgBox("Votre période d'évaluation est expirée depuis le
➥ "& Str(DateAdd("d", 15, DateRegistre)) & vbCr & "Si vous possédez
➥ un code de prolongation, cliquez sur Ok afin de prolonger votre
➥ période d'évaluation de 15 jours.", vbOKCancel + vbQuestion,
➥ "Période d'évaluation expirée")
Programmer en Visual Basic
262 Deuxième partie
Nous avons ajouté lignes 9 à 23 une structure If…Then…Else afin de proposer à l’utilisateur d’entrer
une clé de prolongation si les conditions sont réunies : l’instruction de la ligne 9 vérifie que la valeur
de la clé Abo est "eval" (et que l’utilisateur n’a donc pas encore prolongé la période d’évaluation)
et que le nombre de jours écoulés depuis l’écriture de la date dans la base de registre est inférieur
à 30 (puisque la période d’évaluation ne peut être supérieure à 30 jours). Si ces deux conditions
sont vérifiées, il est proposé à l’utilisateur d’entrer une clé de prolongation. On utilise pour cela
une fonction MsgBox(), ligne 11.
Lignes 12 à 22, une structure If…Then…Else imbriquée définit le comportement du programme
selon que l’utilisateur clique sur Ok dans la boîte de dialogue qui s’affiche (lignes 12 à 19) ou
qu’il clique sur le bouton Annuler (lignes 20 à 22). Dans ce cas, l’instruction End de la ligne 21
met fin au programme en cours d’exécution.
Si l’utilisateur choisit d’entrer une clé d’activation une fenêtre InputBox() est affichée afin de lui
permettre de saisir la clé. Si celle-ci est correcte, l’instruction de la ligne 15 appelle la procédure
de prolongation de licence précédemment créée. Dans le cas contraire, un message est affiché
(ligne 17) et le programme en cours d’exécution prend fin.
Info
Vous pouvez, si vous le souhaitez, améliorer encore ce programme en proposant à l’utilisateur de saisir à
nouveau la clé si celle-ci est erronée. Référez-vous pour cela à la section « Protéger un classeur par mot
de passe » du chapitre 16, dans lequel nous créons un programme qui autorise trois tentatives de saisie
d’un mot de passe.
Écrire et lire dans la base de registre
Chapitre 10
263
Figure 10.9a – En fin de période d'évaluation, l'utilisateur est invité à entrer une clé de prolongation.
Figure 10.9b – Si l'utilisateur valide l'invitation à prolonger la période d'évaluation, la fonction InputBox l'invite
à entrer la clé de prolongation.
Figure 10.9c – Si le code saisi est incorrect, l'utilisateur est averti, puis invité à entrer à nouveau
le code de prolongation.
11
Déboguer et gérer les erreurs
Il arrivera immanquablement que des erreurs surviennent lors de l’exécution d’un programme
VBA ou que le résultat ne soit pas celui qui était escompté. Vous devrez alors déterminer l’ori-
gine de l’erreur et tester de nouveau le programme. VBA dispose pour cela de précieux outils.
Ce chapitre vous les présente.
Vous devez tout d’abord distinguer le débogage de la gestion des erreurs. Le débogage consiste
à corriger un programme qui ne fonctionne pas à cause d’un problème lié au code : faute de
frappe, syntaxe incorrecte, etc. La gestion des erreurs consiste à prévoir les éventuelles erreurs
susceptibles de survenir et à y remédier pour que le programme soit aussi fiable que possible,
c’est-à-dire s’exécutant correctement dans des contextes différents.
Figure 11-1 – Les erreurs de compilation sont les plus faciles à repérer.
Programmer en Visual Basic
266 Deuxième partie
• Erreurs d’exécution. Elles surviennent après que la compilation du programme a été réalisée
avec succès. Elles peuvent, par exemple, être liées à l’utilisation de données incompatibles.
Ce sera le cas si le programme effectue une opération arithmétique sur une variable de chaîne
(voir figure 11-2).
Afficher la rubrique d'aide
associée à l'erreur reconnue
Figure 11-2 – Une valeur et un message définissent le type d’erreur reconnu par Visual Basic.
• Erreurs logiques. Elles sont les plus difficiles à redresser. Contrairement aux autres, elles
laissent le programme s’exécuter. Le résultat obtenu ne sera pas celui que vous escomptiez.
Les sections suivantes présentent les outils de débogage qui aideront à détecter l’origine de l’erreur.
Conseil
L’activation de l’option Vérification automatique de la syntaxe (voir chapitre 5) de Visual Basic Editor repère
les erreurs de syntaxe dès la saisie du code.
Conseil
Il est recommandé de forcer la déclaration explicite des variables à l’aide de l’instruction Option -Expli-
cit. Vous éviterez ainsi tout risque d’erreur lié à une faute de frappe lors de la saisie d’un nom de variable.
Pour plus d’informations reportez-vous au chapitre 6.
Test du projet
Il est d’usage de tester tout nouveau programme lors du développement. Le premier réflexe
consiste à compiler le projet, pour que Visual Basic Editor teste chaque instruction : choisissez
la commande Compiler du menu Débogage. Si une erreur est mise en évidence, remédiez-y.
Et recommencez jusqu’à ce que la compilation se déroule normalement.
Déboguer et gérer les erreurs
Chapitre 11
267
Testez ensuite le projet à partir de Visual Basic Editor : cliquez sur le bouton Exécuter de la barre
d’outils Standard.
Conseil
Ne testez pas un programme dont vous n’êtes pas certain sur un document sensible. Il est préférable de
travailler sur une copie. Vous serez ainsi assuré de ne pas endommager des données précieuses si le
programme ne s’exécute pas correctement, ou s’il produit des résultats erronés.
Si une erreur apparaît à l’exécution, l’instruction coupable est mise en évidence. Remédiez-y. Pour
renouveler le test, cliquez sur le bouton Réinitialiser de la barre d’outils Standard ou choisissez la
commande Réinitialiser du menu Exécution. La mise en évidence de l’instruction source de l’er-
reur d’exécution disparaît. Recommencez jusqu’à ce que le programme s’exécute normalement.
Lorsque survient une erreur de compilation ou d’exécution, il est aisé de repérer l’instruction
erronée. Si le projet a été compilé à partir de Visual Basic Editor, elle est mise en évidence. Si
le programme est exécuté à partir de l’application hôte, la boîte de dialogue de la figure 11-2
s’affiche. Un clic sur le bouton Débogage ouvre Visual Basic Editor (si nécessaire) sur la procé-
dure dans laquelle se trouve l’instruction ayant provoqué l’erreur. Par défaut, celle-ci apparaît en
jaune et est signalée par un indicateur de marge (voir figure 11-3).
Figure 11-3 – L’instruction ayant provoqué l’erreur est mise en évidence dans Visual Basic Editor.
Il est plus difficile de repérer les erreurs logiques. Les outils de débobage de Visual Basic Editor
sont alors d’un grand secours. Ils sont accessibles via le menu Débogage et, pour les plus usités,
via la barre d’outils Débogage.
Basculer le Fenêtre
point d'arrêt Variables
Arrêt Pas à pas locales Fenêtre
principal Espions
Figure 11-5 – Exécutez les procédures pas à pas pour visualiser les conséquences de chacune des instructions.
5. Vous pouvez aussi « lâcher » l’exécution de la procédure en cliquant sur le bouton Continuer
de la barre d’outils Standard. Le programme se poursuit alors normalement.
Vous pouvez aussi exécuter le code procédure par procédure, afin d’étudier la façon dont elles
s’appellent dans le programme. Utilisez pour cela la commande Pas à pas principal. La com-
mande Pas à pas sortant exécute tout le code restant dans la procédure en cours et le programme
s’interrompt juste après l’instruction d’appel.
Déboguer et gérer les erreurs
Chapitre 11
269
Définition
Le mode Arrêt désigne l’état d’une procédure dont l’exécution est interrompue. Cela est dû à une erreur,
à l’exécution pas à pas d’une procédure, à la rencontre d’une instruction End ou Stop, ou à l’interruption
manuelle de l’exécution.
Pour visualiser la valeur d’une variable en survolant cette dernière avec la souris (figure 11-6),
activez l’option Info-bulles automatiques (Outils > Options).
La fenêtre Variables locales donne des informations précises sur toutes les variables visibles à
un moment donné de l’exécution du programme – nom, type et valeur (figure 11-7). Choisissez
pour cela Affichage > Variables locales, ou cliquez sur le bouton Variables locales de la barre
d’outils Débogage.
Figure 11-7 – La fenêtre Variables locales fournit des informations complètes sur les variables.
Dans le haut de la fenêtre, le nom de la procédure en cours d’exécution s’affiche. Les variables
de niveau module apparaissent sous le nom du module, tandis que celles de niveau procédure
sont affichées telles quelles.
Programmer en Visual Basic
270 Deuxième partie
Si la procédure en cours a été appelée, vous pouvez visualiser les variables des procédures appe-
lantes. Cliquez sur le bouton Pile des appels, sur la procédure dont vous souhaitez visualiser les
valeurs, puis sur Afficher. Vous pouvez voir à la figure 11-8 que la procédure Testdeprocédure2
en cours a été appelée par Testdeprocédure1, elle-même appelée par Testdeprocédure. Lorsqu’une
procédure rend la main à celle qui l’a appelée, elle disparaît de la pile.
Figure 11-8 – La pile des appels affiche les appels de procédure actifs.
Vous pouvez modifier les valeurs dans la fenêtre Variables locales, afin de tester le comportement
du programme dans d’autres circonstances. Double-cliquez sur la valeur à changer, puis saisissez
la valeur voulue. Si cette dernière est incompatible avec le type de la variable, un message d’erreur
s’affiche et rien n’est modifié.
Conseil
Lorsque vous quittez Visual Basic Editor, les points d’arrêt ne sont pas enregistrés. Utilisez l’instruction
Stop, qui entraîne le passage de l’exécution d’une procédure en mode Arrêt.
Déboguer et gérer les erreurs
Chapitre 11
271
Figure 11-9 – Les points d’arrêt (ici en gris foncé) définissent des interruptions dans l’exécution du code.
Info
L’instruction suivante ne peut être définie qu’à l’intérieur de la procédure en cours.
Programmer en Visual Basic
272 Deuxième partie
La fenêtre Exécution
En mode Arrêt, la fenêtre Exécution sert à lancer tout type d’instruction qui ne se trouve pas dans
le code du programme. Il suffit d’y écrire l’instruction et d’appuyer sur Entrée ; elle s’exécute alors
comme si elle faisait partie intégrante du code.
Choisissez la commande Fenêtre Exécution, ou cliquez sur le bouton Fenêtre Exécution de la barre
d’outils Débogage, ou encore saisissez le raccourci clavier Ctrl+G. À la figure 11-10, la valeur
indiquée par l’utilisateur et affectée à la variable DateEcheance a provoqué une erreur. Nous avons
placé un point d’arrêt sur l’instruction incriminée, afin d’y revenir par la suite. Nous avons utilisé
la commande Définir l’instruction suivante du menu Débogage pour poursuivre l’exécution du
code à la ligne suivante. Enfin, nous avons redéfini la valeur de DateEcheance à «01/04/2017» et
nous avons relancé l’instruction ayant provoqué l’erreur dans la fenêtre Exécution.
Les espions
Les espions aident à suivre les valeurs de variables ou de toute expression renvoyant une valeur
dans un contexte déterminé. Procédez ainsi :
1. Choisissez la commande Ajouter un espion du menu Débogage (voir figure 11-11).
2. Saisissez l’expression dont vous souhaitez espionner la valeur.
3. Déterminez le contexte dans lequel l’expression sera espionnée. Par défaut, les zones Procédure
et Module affichent respectivement la procédure et le module en cours. Vous pouvez choi-
sir d’espionner la valeur d’une expression dans une procédure d’un module, dans toutes les
Déboguer et gérer les erreurs
Chapitre 11
273
procédures d’un module, ou encore dans tous les modules. Il suffit, en général, de limiter la
portée des espions à celle des expressions espionnées.
4. Dans la zone Type d’espion, choisissez l’une des trois options disponibles :
– Expression espionne. En mode Arrêt, la valeur en cours de l’expression s’affiche dans la
fenêtre Espions.
– Arrêt si la valeur est vraie. La procédure passe en mode Arrêt si la valeur de l’expression
est définie à True.
– Arrêt si la valeur change. L’exécution du code s’interrompt si la valeur de l’expression change.
5. Cliquez sur OK pour valider.
Vous pouvez aussi sélectionner la variable ou l’expression voulue et la faire glisser dans la fenêtre
Espions.
Pour afficher la fenêtre, sélectionnez la commande Fenêtre Espions du menu Affichage, ou cliquez
sur le bouton Fenêtre Espions de la barre d’outils Débogage. Sept espions ont été placés dans la
fenêtre représentée à la figure 11-12.
Sur la figure 11-14, vous voyez que la procédure en cours d’exécution est Procédure3, qui a été
appelée par Procédure2, elle-même appelée par AppelsDeProcédures.
Exemple de débogage
Nous allons créer ici un programme que nous déboguerons jusqu’au moment où nous atteindrons
une version fiable. Nous supposons que nous possédons un classeur Excel contenant de nombreuses
données, mais dans lequel certaines lignes sont vides. Nous décidons donc d’écrire une macro
VBA pour supprimer ces dernières. Nous supposons ici que, lorsqu’une cellule de la colonne A
ne contient pas de données, la ligne est vide et doit être supprimée. Ainsi, les lignes 7, 10, 11 et 16
du classeur représenté à la figure 11-15 doivent être supprimées.
Figure 11-15 – Le programme devra supprimer les lignes ne contenant pas de données.
Programmer en Visual Basic
276 Deuxième partie
Commençons logiquement par définir la zone à traiter (de A1 à la dernière cellule de la colonne A
contenant des données) et l’affecter à une variable objet. Nous utiliserons ensuite une structure
For Each…Next pour vérifier la valeur de chacune des cellules de la zone préalablement définie et
supprimer la ligne correspondante chaque fois qu’il n’y a pas de données. Le programme cor-
respondant se présente ainsi :
1: Sub SupprLignesVidesBoguée()
2: 'Définir la plage à tester
3: 'On commence par définir la dernière cellule
4: 'de la colonne A contenant des données
5: Dim MaPlage As Range
6: Set MaPlage = Range("A1")
7: While Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False)).Value<>""
8: Set MaPlage = Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False))
9: Wend
10: Set MaPlage = Range("A1:" & MaPlage.Address(rowabsolute:=False,
➥ columnabsolute:=False))
11:
12: 'Supprimer les lignes ne contenant pas de données
13: Dim Cellule As Range
14: For Each Cellule In MaPlage
15: If Cellule.Value="" Then
16: Rows(Cellule.Row).Delete
17: End If
18: Next Cellule
19: End Sub
Lignes 5 à 10, la plage de cellules à tester est définie et affectée à la variable MaPlage de type Range.
On commence par déclarer cette dernière et lui affecter la cellule A1 (lignes 5 et 6). Lignes 7 à 9,
une structure While…Wend sert à définir la dernière cellule de la colonne A contenant des données.
MaPlage se voit affecter la cellule renvoyée par la propriété End (ligne 8), tant que celle-ci n’est pas
vide (ligne 7). Lorsque la condition n’est plus vérifiée, la cellule affectée à MaPlage est la dernière
contenant des données. La boucle While…Wend prend alors fin. Ligne 10, MaPlage est redéfinie de A1
à la dernière cellule identifiée.
Lignes 14 à 18, une instruction For Each…Next est utilisée pour tester chacune des cellules de
MaPlage. Une instruction conditionnelle vérifie si la cellule est vide, auquel cas la ligne corres-
pondante est supprimée (ligne 16).
Recherche du bogue
Exécutez le programme sur un classeur Excel contenant des lignes vides. Vous constatez que, s’il
existe deux lignes vides consécutives, la deuxième n’est pas supprimée.
Déboguer et gérer les erreurs
Chapitre 11
277
Figure 11-16 – Exécutez la macro pas à pas et observez attentivement ses effets sur la feuille Excel,
ainsi que les valeurs que prennent les variables.
5. Vous devriez vous rendre compte que, lorsque la ligne 10 est supprimée, la ligne 11 prend sa
place et que la cellule suivante testée est A11. Le contenu de la cellule précédemment en A11
ne sera donc pas traité, puisqu’il est passé en A10.
La boucle For Each…Next traite les cellules de MaPlage une à une. Or, lorsqu’une ligne est sup-
primée, la suivante prend sa place et elle est donc ignorée par la procédure.
Programmer en Visual Basic
278 Deuxième partie
Résolution du bogue
Plusieurs solutions permettent de régler ce problème.
Vous pouvez intégrer une instruction contrôlant de nouveau le contenu de la cellule lorsqu’une
ligne est supprimée :
If Cellule.Value="" Then
Dim LigneSuppr As Long
LigneSuppr = Cellule.Row
Rows(Cellule.Row).Delete
If Range("A" & LigneSuppr)="" Then
Rows(Range("A" & LigneSuppr).Row).Delete
End If
End If
Avant de supprimer une ligne, son numéro est stocké dans LigneSuppr. La ligne est ensuite suppri-
mée. Une instruction conditionnelle imbriquée la supprime à nouveau si la cellule de la colonne A
correspondante est encore vide. Le problème est ainsi réglé si deux lignes consécutives sont vides,
mais pas s’il en existe plus de deux.
Une autre solution consiste à utiliser une structure For…Next à la place de For Each…Next. Vous
définirez un déroulement de la boucle commençant par la dernière cellule plutôt que par la pre-
mière. Le programme se présente alors ainsi :
Sub SupprLignesVidesVersion2()
Dim MaPlage As Range
Set MaPlage = Range("A1")
While Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False)).Value<>""
Set MaPlage = Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False))
Wend
Dim DerLigne As Long
DerLigne = MaPlage.Row
'Supprimer les lignes ne contenant pas de données
Dim Compteur As Long
For Compteur = DerLigne To 1 Step -1
If Range("A" & Compteur).Value="" Then
Rows(Range("A" & Compteur).Row).Delete
End If
Next Compteur
End Sub
Une troisième solution consistera à stocker la liste des cellules vides dans une variable de matrice
et à ne procéder à la suppression des lignes vides qu’une fois la liste définie. On devra là aussi
partir de la dernière jusqu’à atteindre la première.
Déboguer et gérer les erreurs
Chapitre 11
279
1: Sub SupprLignesVidesVersion3()
2: 'Création d'une variable de matrice redimensionnable
3: Dim MonTableau()
4:
5: 'Définir la plage à tester
6: Dim MaPlage As Range
7: Set MaPlage = Range("A1")
8: While Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False)).Value<>""
9: Set MaPlage = Range(MaPlage.End(xlDown).Address(rowabsolute:=False,
➥ columnabsolute:=False))
10: Wend
11: Set MaPlage = Range("A1:" & MaPlage.Address(rowabsolute:=False,
➥ columnabsolute:=False))
12:
13: 'On stocke dans la variable de matrice les valeurs
14: 'de toutes les lignes à supprimer
15: Dim Cellule As Range
16: For Each Cellule In MaPlage
17: If Cellule.Value="" Then
18: 'Une erreur sera générée à l'appel de la fonction
19: 'UBound si le tableau n'a encore reçu aucune valeur
20: On Error Resume Next
21: ReDim Preserve MonTableau(UBound(MonTableau) + 1)
22: 'L'instruction conditionnelle suivante gère cette erreur
23: If Err.Number=9 Then
24: ReDim MonTableau(1)
25: Err.Clear
26: End If
27: MonTableau(UBound(MonTableau)) = Cellule.Row
28: End If
29: Next Cellule
30:
31: 'Suppression des lignes vides
32: Dim Compteur As Single
33: For Compteur = UBound(MonTableau) To LBound(MonTableau) Step -1
34: Rows(MonTableau(Compteur)).Delete
35: Next Compteur
36: End Sub
L’instruction Option Base 1 a été placée dans la zone de déclaration du module, de façon que la
première valeur d’index des tableaux soit 1 et non 0.
Ligne 3, un tableau redimensionnable est déclaré. Il servira à stocker les numéros des lignes à
supprimer. Lignes 6 à 11, la zone à traiter est définie et affectée à MaPlage.
Lignes 15 à 29, les numéros des lignes à supprimer sont définis et stockés dans MonTableau. La
variable Cellule de type Range est tout d’abord déclarée. Une structure For Each…Next sert ensuite
à tester l’ensemble des cellules de MaPlage (lignes 16 à 29). À chaque passage de la boucle, une
structure conditionnelle (lignes 17 à 28) évalue le contenu de la cellule testée et stocke le numéro
de la ligne dans MonTableau si la cellule est vide. La variable est tout d’abord redimensionnée
Programmer en Visual Basic
280 Deuxième partie
(ligne 21). On se sert pour cela de la fonction UBound qui renvoie la taille du tableau, à laquelle
on ajoute 1. Ligne 27, le dernier espace de stockage de MonTableau reçoit le numéro de la ligne
à supprimer.
Rappel
Notez l’utilisation du mot-clé Preserve lors du redimensionnement du tableau (ligne 21). Celui-ci est indis-
pensable pour que le tableau ne soit pas réinitialisé.
Lignes 20 à 26, un gestionnaire d’erreur a été mis en place. En effet, la première fois que la fonction
UBound est utilisée (ligne 21), une erreur est générée. L’instruction Resume Next de la ligne 20 force
le passage à l’instruction suivante en cas d’erreur. Ligne 23, on teste la valeur de la propriété Number
de l’objet Err pour vérifier si une erreur a été générée. Si tel est le cas, MonTableau est dimensionné
avec un seul espace de stockage et l’objet Err est réinitialisé à l’aide de la méthode Clear.
Conseil
Pour connaître le numéro d’une erreur (la valeur de la propriété Number de l’objet Err), provoquez-la volon-
tairement et relevez le numéro indiqué dans la boîte de dialogue Visual Basic affichée.
Lignes 32 à 35, les lignes vides sont supprimées. On utilise pour cela une boucle For…Next dont
le compteur commence à la valeur d’index la plus importante de MonTableau pour atteindre la
valeur la plus basse, en décrémentant de 1 à chaque passage. Dans la boucle, l’instruction de la
ligne 34 supprime la ligne dont le numéro correspond à la valeur stockée dans l’espace d’index
Compteur de MonTableau.
Info
L’intérêt de cette version du programme est de stocker les lignes supprimées dans une variable. Placez
les instructions suivantes en fin de programme pour afficher le nombre et la liste des lignes supprimées :
Dim Message As String
Message = UBound(MonTableau) & " lignes ont été supprimées :"
For Compteur = 1 to UBound(MonTableau)
Message = Message & vbCr & MonTableau(Compteur)
Next Compteur
MsgBox Message, vbOKOnly + vbInformation
En l’état, le programme lancera encore une erreur à la ligne 33 si aucune ligne n’est à supprimer.
Corrigez ce bogue selon la méthode de votre choix : soit en encadrant les instructions par une
structure conditionnelle qui vérifiera que MonTableau n’est pas vide, soit par la mise en place d’un
gestionnaire d’erreur.
Déboguer et gérer les erreurs
Chapitre 11
281
Une telle méthode se révélera particulièrement intéressante si vous créez une procédure suppri-
mant des lignes dont vous souhaitez récupérer les informations dans un autre classeur Excel. Vous
utiliserez alors une variable de matrice dynamique à deux dimensions : l’une correspondant aux
lignes du classeur, l’autre aux colonnes. La taille de la première dimension (le nombre de lignes
à supprimer ou le nombre de colonnes du classeur contenant des données à conserver) devra être
définie avant de stocker les données dans la variable – seule la dernière dimension pouvant être
redéfinie ena conservant les valeurs de la variable.
Définition
Un gestionnaire d’erreur est un ensemble d’instructions qui est censé permettre la poursuite de l’exécution
d’une procédure. En général, il est appelé par un détecteur d’erreur.
Pour détecter une éventuelle erreur, placez une instruction On Error devant l’instruction suscep-
tible d’en lancer une :
• On Error Resume Next ignore l’instruction ayant provoqué une erreur et passe à la suivante.
• On Error GoTo étiquette appelle un gestionnaire d’erreur repéré par l’étiquette.
Programmer en Visual Basic
282 Deuxième partie
Ainsi, dès qu’une erreur est détectée, le gestionnaire est appelé. L’instruction Resume ne peut être
placée que dans un tel gestionnaire : elle rend la main à l’instruction ayant provoqué une erreur,
qui s’exécute de nouveau. Si aucune erreur ne se reproduit, le programme se déroule normalement
jusqu’à l’instruction Exit Sub. La procédure s’achève alors, sans que le gestionnaire d’erreur ait
été exécuté.
Lorsqu’une erreur survient, son type est affecté à la propriété Number de l’objet Err. Après gestion
de l’erreur, il est important de réinitialiser cette propriété afin que les éventuelles autres erreurs
puissent être détectées : Err.Number = 0.
Modifiez-la comme suit : un gestionnaire d’erreur affiche une nouvelle boîte de dialogue
dans laquelle l’utilisateur est invité à entrer une date dans un format valide. L’instruction
ayant provoqué l’erreur est alors répétée et le programme se déroule normalement, jusqu’à
l’instruction Exit Sub qui entraîne la sortie de la procédure. Si l’utilisateur clique sur le
bouton Annuler, la variable DateEcheance renverra Empty et l’instruction Exit Sub entraînera
la sortie du programme.
Sub VerifierEcheances()
Dim ZoneATester As String
ZoneATester = ActiveWindow.RangeSelection.Address
If ZoneATester=Null Then
MsgBox "Sélectionnez la plage de cellules à tester.", _
vbOKOnly + vbInformation
Exit Sub
End If
Dim DateEcheance As Variant
DateEcheance = InputBox("Indiquez la date d'échéance.", _
"Echéance des opérations en cours", Date + 30)
If DateEcheance="" Then
Exit Sub
End if
On Error GoTo GestionnaireErreur
Programmer en Visual Basic
284 Deuxième partie
DateEcheance = CDate(DateEcheance)
Dim CellTest As Range
For Each CellTest In Range(ZoneATester)
If IsDate(CellTest)=True Then
If CellTest.Value>DateEcheance Then
CellTest.Interior.ColorIndex = 6
End If
End If
Next
Exit Sub
GestionnaireErreur:
Err.Number = 0
DateEcheance = InputBox("Format de date non valide." & _
Chr(10) & "Entrez une date au format jj/mm/aa", "Erreur gérée", _
"jj/mm/aa")
If DateEcheance=Empty Then Exit Sub
Resume
End Sub
Une fois vos applications Excel créées, il reste à en assurer un accès simple et intuitif pour les
utilisateurs. Si passer par la boîte de dialogue Macros pour exécuter une macro est une méthode
adaptée aux développeurs, elle ne l’est pas pour les utilisateurs lambda d’Excel ; non seulement
parce qu’elle n’est pas intuitive, mais aussi parce que l’onglet Développeur n’est pas affiché par
défaut dans le ruban Excel. Il convient donc de simplifier l’exécution des macros par une meilleure
intégration dans Excel.
Au cours de ce chapitre, vous apprendrez à :
• affecter un raccourci clavier à une macro ;
• personnaliser la barre d’outils Accès rapide et les onglets du ruban Office ;
• affecter une macro à un bouton de commande ;
• affecter une macro à un objet tel qu’un graphique ;
• créer un onglet personnalisé avec Custom UI Editor for Microsoft Office.
Cette dernière solution est la plus complexe car elle consiste à créer un fichier XML. En revanche,
elle est aussi celle qui offre le plus de souplesse et de possibilités. Par ailleurs, c’est la seule solu-
tion pour créer un onglet qui sera affecté à votre modèle complémentaire et en permettra ainsi
une diffusion simple sur d’autres postes.
Programmer en Visual Basic
286 Deuxième partie
Commencez par créer la procédure MacroTest dans le classeur de macros personnelles. Elle
affichera une simple boîte de dialogue afin de s’assurer qu’elle est bien exécutée :
Sub MacroTest()
MsgBox "Exécution de la macro test"
End Sub
Info
Excel est sensible à la casse du raccourci choisi. Ainsi, si vous saisissez la lettre « z », le raccourci sera
Ctrl + z. En revanche, si vous saisissez la lettre « Z », le raccourci sera Ctrl + Maj + z.
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
287
Figure 12-3 – Sélectionnez le contrôle de votre choix afin de le déposer sur la feuille Excel.
• Il s’agit d’une procédure événementielle. Nous étudierons ce type de procédure en détail dans
le chapitre suivant, lors de la création d’interface utilisateur. Pour l’instant, sachez simplement
que celle-ci s’exécute lorsque l’utilisateur clique sur le bouton de commande CommandButton1.
• Vous pouvez rédiger directement dans cette procédure le code qui s’exécutera ou appeler la
procédure de votre choix en plaçant simplement une instruction Call. Pour l’instant, contentez-
vous d’y placer l’instruction MsgBox comme suit :
Private Sub CommandButton1_Click()
MsgBox "Exécution de la macro affectée au bouton"
End Sub
Figure 12-4 – La macro est exécutée par un simple clic sur le bouton.
Le curseur prend maintenant la forme d’une main lorsqu’il est placé au-dessus de l’objet en ques-
tion. Un clic sur celui-ci déclenche la macro.
Figure 12-6 – La transformation du curseur en main lors du survol de l’objet incite l’utilisateur à cliquer.
Programmer en Visual Basic
290 Deuxième partie
notre exemple Ma macro). Choisissez l’image qui sera affichée sur la barre d’outils parmi les
images proposées. Cliquez sur le bouton OK (figure 12-8).
Figure 12-8 – Choisissez le nom et l’image qui seront affichés sur la barre d’outils Accès rapide.
7. Enfin, utilisez les flèches situées sur la droite de la fenêtre pour définir la position de votre
commande sur la barre d’outils, puis validez.
8. Cliquez sur le nouveau bouton de la barre d’outils Accès rapide pour exécuter la macro
(figure 12-9).
Info
Pour supprimer une commande personnalisée, cliquez-droit dessus et choisissez la commande Supprimer
du menu contextuel.
Programmer en Visual Basic
292 Deuxième partie
Figure 12-10 – Le nouvel onglet créé contient un seul groupe par défaut.
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
293
Info
Le terme groupe désigne un ensemble de commandes au sein d’un onglet. Un onglet contient en général
plusieurs groupes afin d’offrir un accès par types de fonctions. Les groupes sont séparés par une barre
verticale, et leur nom est affiché sous les commandes qui le constituent.
5. Cliquez-droit sur le nouvel onglet et choisissez Renommer. Dans la boîte de dialogue qui
s’affiche, saisissez « Mon onglet perso », puis validez. Procédez de même pour le groupe situé
sous l’onglet que vous venez de créer et renommez-le « Mon groupe ». Remarquez que les
noms affectés sont suivis de « (Personnalisé) ».
6. Sélectionnez MacroTest dans le volet gauche, puis cliquez sur Ajouter. Son nom apparaît dans
le groupe sélectionné du nouvel onglet. Renommez-la en « Ma macro » comme vous l’avez
fait pour l’onglet et le groupe à l’étape précédente. Choisissez ensuite une image parmi celles
qui vous sont proposées.
7. Enfin, utilisez les flèches situées sur la droite de la fenêtre pour définir la position de votre
commande sur l’onglet, puis validez. Dans notre exemple, nous l’avons placé après l’onglet
Accueil.
8. Activez l’onglet Mon onglet perso et cliquez sur le bouton pour exécuter la macro.
Programmer en Visual Basic
294 Deuxième partie
Info
Pour supprimer une commande personnalisée, cliquez-droit dessus et choisissez la commande Supprimer
du menu contextuel.
Figure 12-13 – L’onglet Audit permet d’exécuter simplement les macros de notre modèle complémentaire.
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
295
La création d’un ruban consiste en un fichier XML qui est attaché à votre modèle. Nous supposons
ici que vous connaissez les principes de base du balisage XML et ne nous attarderons donc pas
sur le sujet. Pour créer le fichier XML de personnalisation du ruban, nous utiliserons Custom
UI Editor for Microsoft Office, un utilitaire gratuit développé par Open XML Developer.Org.
Commencez par installer cet outil. Le programme d’installation OfficeCustomUIEditorSetup.zip
se trouve dans le dossier de ressources de ce livre. Vous pouvez également effectuer une recherche
sur Internet et le télécharger.
Après installation, créez un nouveau fichier Excel et enregistrez-le au format gérant les macros
(*.xlsm) sous le nom test.xlsm.
Info
Nous écrirons maintenant CUIE pour désigner Custom UI Editor for Microsoft Office.
Figure 12-16 – Custom OutSpace : personnalisation de la page d’accueil d’Excel (menu Fichier).
3. Cliquez-droit sur le fichier qui apparaît maintenant dans le volet gauche de CUIE. Le menu
contextuel qui s’affiche propose deux options :
– Office 2010 Custom UI Part créera un fichier XML valide pour les versions 2010 et ulté-
rieures d’Excel, nommé CustomUI11.xml.
– Office 2007 Custom UI Part créera un fichier XML valide pour les versions 2007 et ulté-
rieures d’Excel, nommé CustomUI.xml.
Choisissez la première option. Le nom du fichier CustomUI11.xml apparaît maintenant sous
celui de notre fichier Excel.
4. Pour chacun des cinq exemples de fichiers XML, procédez comme suit :
– Choisissez la commande Insert, Sample XML, puis sélectionnez l’exemple.
– Cliquez sur le bouton Enregistrer.
– Ouvrez le fichier dans Excel et observez les personnalisations du ruban.
Figure 12-17 – Création d’un nouvel onglet contenant une seule commande.
1: <customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
2: <ribbon startFromScratch="false">
3: <tabs>
4: <tab id="customTab" label="Custom Tab">
5: <group id="customGroup" label="Custom Group">
6: <button id="customButton" label="Custom Button"
➥ imageMso="HappyFace" size="large" onAction="Callback" />
7: </group>
8: </tab>
9: </tabs>
10: </ribbon>
11: </customUI>
Les lignes 1 et 11 constituent le cadre de notre structure XML. Les fichiers customUI.xml com-
mencent et finissent toujours par ces deux instructions. Les balises 2 et 10 indiquent que l’on
personnalise le ruban (ribbon). L’attribut startFromScratch définit si les onglets prédéfinis d’Excel
sont ou non affichés. Cet attribut peut être ignoré, sa valeur par défaut étant alors false. Si vous le
définissez à true, seuls les onglets de votre fichier XML seront affichés sur le ruban d’Office. Dans
cet exemple, cet attribut aurait donc pu être ignoré ; la structure suivante est donc équivalente :
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
<ribbon>
…
</ribbon>
</customUI>
Il s’agit d’une balise <tab>. Tous les éléments XML qui définissent un onglet sont situés entre les
balises <tab> et </tab>. Deux attributs sont définis ici : id reçoit la valeur customTab, tandis que
label se voit affecter la chaîne Custom Tab. Le premier est l’identifiant de notre onglet. Comme
nous le verrons plus loin, les attributs id permettent de manipuler dynamiquement les éléments
d’un onglet via du code VBA. Les balises d’un fichier customUI.xml ont ainsi pour la plupart
un attribut id qui les identifie de façon unique. L’attribut label définit l’intitulé de l’élément qui
sera affiché sur le ruban, ici Custom Tab. Vous retrouverez cet attribut pour tous les éléments qui
portent un nom (l’onglet, les groupes, les boutons…).
Les balises <group>...</group> des lignes 5 et 7 créent un groupe intitulé Custom Group sur le
ruban. Dans le jargon Office, un « groupe » constitue un ensemble de commandes réunies sous
un même intitulé et est séparé des groupes adjacents par des barres verticales. Sur la figure 12-13
de notre exemple, p. 274, on voit qu’il existe quatre groupes : Audit, Outils, Utilisateurs, Aide.
Enfin, entre ces deux balises se trouve le seul bouton de notre onglet, défini par la balise <button> :
<button id="customButton" label="Custom Button" imageMso="HappyFace" size="large"
➥ onAction="Callback" />
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
299
Attention
Notez au passage que le code XML est sensible à la casse. Vous devez respecter l’usage des minuscules
et des majuscules.
Là encore, CUIE fournit un outil très pratique pour les développeurs, qui génère les instructions
Sub()...End Sub des procédures affectées aux éléments de l’onglet. Il suffit ensuite de copier les
instructions ainsi générées, puis de les coller dans un module de code VBA du fichier Excel.
Procédez comme suit :
1. Ouvrez le fichier test.xlsm dans CUIE.
2. Cliquez sur le bouton Generate Callbacks (5e et dernier bouton de la barre d’outils).
• CUIE génère la procédure associée au seul bouton de notre onglet (figure 12-20).
8. Retournez à Excel, puis cliquez sur le bouton Custom Button de l’onglet Custom Tab.
La procédure associée est exécutée et la boîte de dialogue est affichée (figure 12-22).
Ici, cinq propriétés du bouton sont définies via les cinq attributs id, label, imageMso, size et
onAction.
Le tableau 12-1 présente les contrôles les plus courants, tandis que le tableau 12-2 présente les
attributs incontournables, ceux que vous devez connaître.
Attribut Description
id Identifiant unique d’un contrôle. Une erreur est générée si une même valeur est affectée à
deux contrôles distincts.
label Intitulé du contrôle.
insertAfterMso Cet attribut de la balise tab sert à définir après quel onglet prédéfini d’Excel doit se situer
l’onglet personnalisé.
size Définit la taille du contrôle. Cet attribut peut prendre les valeurs large ou normal.
onAction Reçoit pour valeur le nom de la procédure qui doit être exécutée lorsque l’événement principal
du contrôle est détecté (en général un clic).
imageMso Permet d’affecter au contrôle une des images de la banque d’images Office.
screentip Titre de la bulle d’aide (en gras) affichée lorsque le curseur est placé au-dessus du contrôle.
supertip Énoncé de la bulle d’aide lorsque le curseur est placé au-dessus du contrôle. L’énoncé est
placé sous le titre de la bulle et apparaît en maigre.
visible Permet de masquer ou d’afficher un contrôle.
Figure 12-23 – Placez le curseur au-dessus d’une image pour en afficher le nom.
Programmer en Visual Basic
306 Deuxième partie
Notez que les images intégrées d’Office ne s’affichent pas de la même façon selon la version
d’Excel utilisées (figures 12-24 et 12-25)
</tab>
</tabs>
</ribbon>
</customUI>
4. Cliquez sur le bouton Validate afin de vous assurer que votre code est correct.
5. Enregistrez le fichier.
Nous avons en premier lieu ajouté un commentaire afin de faciliter la lecture du code XML ; nous
ferons de même pour chaque groupe créé. Nous avons ensuite modifié les valeurs des attributs id
(l’identifiant) et label (l’intitulé) des balises tab (l’onglet), group (le groupe) et button (le bouton).
Nous avons également ajouté l’attribut insertAfterMso à la balise Tab et lui avons affecté la valeur
TabView, afin que notre onglet s’affiche après Affichage dans le ruban. Enfin, nous avons modifié
ou ajouté quatre autres attributs pour le bouton :
• onAction : nous lui avons associé le nom de la procédure VBA qui sera exécutée, CPAnalyse.
Nous créerons celle-ci plus tard.
• imageMso : nous avons modifié l’image du bouton en lui affectant l’Id de ZoomPrintPreviewExcel
(une loupe).
• screentip et supertip : nous avons ajouté ces deux attributs, qui correspondent respectivement
au titre et à l’énoncé de la bulle d’aide affichée lorsqu’on passe le curseur au-dessus du bouton.
Ouvrez maintenant le fichier audit.xlsm et activez l’onglet Audit (figure 12-26). Fermez le fichier.
Figure 12-27 – Procédez par copier-coller de code XML afin d’éviter des erreurs de saisie.
2. Placez le curseur sous la balise de fermeture du groupe Audit (</group>) et collez le contenu
du presse-papiers à trois reprises.
3. Modifiez le code XML comme ci-après. Notez que nous avons modifié les commentaires ainsi
que les attributs id et label des trois nouveaux groupes, mais également la valeur id du bouton.
Même si ce dernier est provisoire, un même id provoquerait une erreur :
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
<ribbon>
<tabs>
<tab id="OngletAudit" label="Audit" insertAfterMso="TabView">
<!--
Groupe audit
-->
<group id="Audit" label="Audit">
<button id="btnanalyse" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
309
<!--
Groupe Outils
-->
<group id="Outils" label="Outils">
<button id="btnanalyse2" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
<!--
Groupe Utilisateurs
-->
<group id="Utilisateurs" label="Utilisateurs">
<button id="btnanalyse3" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
<!--
Groupe Aide
-->
<group id="Aide" label="Aide">
<button id="btnanalyse4" label="Analyse" size="large" onAction="CPAnalyse"
imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
4. Validez afin de vous assurer que votre code est correct, puis enregistrez.
Ouvrez maintenant le fichier audit.xlsm et activez l’onglet Audit (figure 12-28). Fermez le fichier.
3. Collez le code autant de fois que nécessaire dans chaque groupe, afin d’obtenir le nombre de
boutons voulu pour chaque groupe.
Info
Pour qu’un groupe s’ affiche sur son onglet, il doit contenir au moins un contrôle. Dans notre exemple,
conservez donc le bouton Analyse.
4. Modifiez les valeurs des attributs id, label, onAction et imageMso de chaque balise <button>
comme dans le code ci-après et affectez la valeur normal à l’attribut size des cinq boutons du
groupe Outils, qui doivent être de petite taille.
5. Enfin, ajoutez quatre balises separator entre les codes des boutons qui doivent être séparés
par un trait vertical.
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
<ribbon>
<tabs>
<tab id="OngletAudit" label="Audit" insertAfterMso="TabView">
<!--
Groupe audit
-->
<group id="Audit" label="Audit">
<button id="btnanalyse" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id=”MySeparator1” />
<button id="btnNettoyage" label="Nettoyage" size="large"
➥ onAction="CPNettoyage" imageMso="FormatPainter" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id=”MySeparator2” />
<button id="btnValidation" label="Validation" size="large"
➥ onAction="CPValidation" imageMso="Spelling" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id=”MySeparator3” />
<button id="btnConsolidation" label="Consolidation" size="large"
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
311
<!--
Groupe Outils
-->
<group id="Outils" label="Outils">
<button id="btnConfig" label="Configuration" size="normal" onAction="CPConfig"
➥ imageMso="AdpDiagramNewTable" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnMEP" label="Mise en pages" size="normal"
➥ onAction="CPMiseEnPage" imageMso="CreateTable" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnCpteRendu" label="Compte rendu" size="normal"
➥ onAction="CPCompteRendu" imageMso="SignatureLineInsert" screentip="Ceci
➥ est le screentip du contrôle" supertip="Ceci est le supertip du
➥ contrôle"/>
<separator id="MySeparator4" />
<button id="btnTrier" label="Trier les données" size="normal"
➥ onAction="CPTrier" imageMso="Numbering" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnConsolider" label="Consolider les données" size="normal"
➥ onAction="CPConsolider" imageMso="FootnoteInsert" screentip="Ceci est
➥ le screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
<!--
Groupe Utilisateurs
-->
<group id="Utilisateurs" label="Utilisateurs">
<button id="btnanalyse3" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</group>
<!--
Groupe Aide
-->
<group id="Aide" label="Aide">
<button id="btnDecouvrir" label="Découvrir" size="large"
➥ onAction="CPDecouvrir" imageMso="QueryBuilder" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnCommentaire" label="Commentaire" size="large"
➥ onAction="CPSuggestion" imageMso="EnvelopesAndLabelsDialog"
➥ screentip="Ceci est le screentip du contrôle" supertip="Ceci est le
➥ supertip du contrôle"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
Programmer en Visual Basic
312 Deuxième partie
6. Assurez-vous que le code XML ainsi modifié est correct en cliquant sur le bouton Validate.
7. Enregistrez, puis ouvrez le fichier audit.xlsm dans Excel.
L’onglet Audit se présente maintenant comme sur la figure 12-29. Fermez le fichier.
Figure 12-31 – Les menus ont été créés mais sont vides à cette étape.
<!--
Groupe Utilisateurs
-->
<group id="Utilisateurs" label="Utilisateurs">
<menu id="MenuUtilisateurs" label="Utilisateurs" size="large"
➥ imageMso="MeetingsWorkspace" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle">
<button id="btnListeUtilisateurs" label="Liste des utilisateurs"
➥ onAction="CPListe" imageMso="FileCheckOut" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnAjouterUtilisateurs" label="Ajouter un utilisateur"
➥ onAction="CPAjouterUtilisateurs" imageMso="FileCheckIn"
➥ screentip="Ceci est le screentip du contrôle" supertip="Ceci est le
➥ supertip du contrôle"/>
<menuSeparator id="separator" />
<button id="Connexion" label="Connexion" onAction="CPConnexion"
➥ imageMso="ContactPictureMenu" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</menu>
<menu id="MenuLangage" label="Langue" size="large" imageMso="SetLanguage"
➥ screentip="Ceci est le screentip du contrôle" supertip="Ceci est le
➥ supertip du contrôle">
<button id="btnFR" label="Français" onAction="ChangerLangue"
➥ imageMso="AcceptInvitation" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnEN" label="Anglais" onAction="ChangerLangue"
➥ imageMso="AcceptInvitation" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</menu>
</group>
<!--
Groupe audit
-->
<group id="Audit" label="Audit">
<button id="btnanalyse" label="Analyse" size="large" onAction="CPAnalyse"
➥ imageMso="ZoomPrintPreviewExcel" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id="MySeparator1" />
<button id="btnNettoyage" label="Nettoyage" size="large"
➥ onAction="CPNettoyage" imageMso="FormatPainter" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id="MySeparator2" />
<button id="btnValidation" label="Validation" size="large"
➥ onAction="CPValidation" imageMso="Spelling" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<separator id="MySeparator4" />
<button id="btnConsolidation" label="Consolidation" size="large"
➥ onAction="CPConsolidation" imageMso="AddInManager" screentip="Ceci est
➥ le screentip du contrôle" supertip="Ceci est le supertip du
➥ contrôle"/>
</group>
<!--
Groupe Outils
-->
<group id="Outils" label="Outils">
<button id="btnConfig" label="Configuration" size="normal" onAction="CPConfig"
➥ imageMso="AdpDiagramNewTable" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
317
<!--
Groupe Utilisateurs
-->
<group id="Utilisateurs" label="Utilisateurs">
<menu id="MenuUtilisateurs" label="Utilisateurs" size="large"
➥ imageMso="MeetingsWorkspace" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle">
<button id="btnListeUtilisateurs" label="Liste des utilisateurs"
➥ onAction="CPListe" imageMso="FileCheckOut" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnAjouterUtilisateurs" label="Ajouter un utilisateur"
➥ onAction="CPAjouterUtilisateurs" imageMso="FileCheckIn"
➥ screentip="Ceci est le screentip du contrôle" supertip="Ceci est le
➥ supertip du contrôle"/>
<menuSeparator id="separator" />
<button id="Connexion" label="Connexion" onAction="CPConnexion"
➥ imageMso="ContactPictureMenu" screentip="Ceci est le screentip du
➥ contrôle" supertip="Ceci est le supertip du contrôle"/>
</menu>
Programmer en Visual Basic
318 Deuxième partie
<!--
Groupe Aide
-->
<group id="Aide" label="Aide">
<button id="btnDecouvrir" label="Découvrir" size="large"
➥ onAction="CPDecouvrir" imageMso="QueryBuilder" screentip="Ceci est le
➥ screentip du contrôle" supertip="Ceci est le supertip du contrôle"/>
<button id="btnCommentaire" label="Commentaire" size="large"
➥ onAction="CPSuggestion" imageMso="EnvelopesAndLabelsDialog"
➥ screentip="Ceci est le screentip du contrôle" supertip="Ceci est le
➥ supertip du contrôle"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
La première ligne est un commentaire qui indique à quel contrôle et quel attribut est associée
la procédure. Le nom de cette dernière, ici CPAnalyse, correspond à la valeur de l’attri-
but onAction du contrôle. Le contrôle est passé comme paramètre à la procédure VBA par
Intégrer des applications VBA dans l’environnement d’Excel
Chapitre 12
319
Figure 12-33 – Les instructions d’ouverture et de fin des procédures VBA sont générées automatiquement.
Figure 12-34 – Notre ruban est maintenant fonctionnel et exécute les macros de notre modèle Excel.
Info
Notez qu’il est possible de charger dynamiquement l’onglet par code VBA. On utilise pour cela la fonc-
tion onLoad qui est exécutée une seule fois, lors du chargement de l’onglet. Elle charge en mémoire une
variable objet de type IRibbonUI qui fait référence à notre onglet et pourra ensuite être utilisée à tout
moment pour agir sur celui-ci.
La fonction onLoad se place dans la balise d’ouverture du code XML et lance l’exécution de la procédure
qui lui est affectée. Sa syntaxe est la suivante :
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui"
➥ onLoad="NomProcédure">
Il suffit d’insérer ensuite le code VBA qui chargera en mémoire l’onglet :
Public MonOnglet As IRibbonUI
Développer
des interfaces
utilisateur
13
Créer des interfaces utilisateur
Les feuilles constituent un élément essentiel de la programmation Visual Basic. Ce sont des
zones sur lesquelles vous placez des contrôles tels que des cases à cocher, des boutons d’option,
des zones de texte, des boutons de commande, etc. Ils forment une interface graphique simple et
intuitive entre l’utilisateur et le programme.
Un événement utilisateur, tel qu’un clic de souris ou une modification de valeur, qui touche un
contrôle est automatiquement repéré par le programme et lance l’exécution du code que vous lui
avez associé. On parle alors de procédure événementielle ou procédure d’événement.
Les contrôles prennent une valeur, déterminée par leur état (case cochée ou non cochée, texte d’une
zone de texte, etc.). L’exploitation des feuilles consiste généralement à passer à une procédure de
code les informations que l’utilisateur entre sur la feuille (les valeurs des différents contrôles) et
valide – en cliquant sur un bouton libellé OK, par exemple. Ces données sont ensuite exploitées
par le programme.
• Création visuelle de la feuille. Durant cette phase, vous allez dessiner votre feuille dans Visual
Basic Editor. Vous créerez la feuille et y placerez les contrôles voulus (cases à cocher, boutons
d’option). Vous paramétrerez les propriétés de la feuille et des contrôles qui la composent, afin
d’en déterminer l’apparence (couleur, taille, texte par défaut) et le comportement (accessibilité,
nombre de caractères autorisés, etc.).
• Écriture du code attaché à la feuille. Sans code affecté aux différents éléments qui la composent,
une feuille n’est qu’une jolie boîte de dialogue sans fonctionnalité. Durant cette phase, vous
déterminerez son comportement face aux différents événements susceptibles de l’affecter et
écrirez le code exploitant les données fournies par l’utilisateur.
Ce chapitre présente la création de feuilles. Vous y découvrirez les différents contrôles à votre
disposition, apprendrez à les placer et à utiliser les outils de VBA pour créer des interfaces à
l’apparence professionnelle. Les outils de développement visuel de feuilles de Visual Basic faci-
litent la création d’interfaces complètes, semblables aux boîtes de dialogue des applications Office.
3. Une fenêtre UserForm s’ouvre (voir figure 13-2). La feuille et la boîte à outils y sont affi-
chées. Par défaut, la feuille est intitulée UserForm1, UserForm2 s’il existe déjà une feuille
UserForm1, etc.
Pour ouvrir la fenêtre UserForm d’une feuille existante, ouvrez l’Explorateur de projet (Ctrl+R)
et double-cliquez sur celle-ci.
Contrôle Picture
Outil Sélection
L’outil Sélection sert à choisir un ou plusieurs contrôles sur une feuille. Il est activé par défaut
dans la boîte à outils. Cet outil redevient actif dès que le contrôle choisi est déposé sur la feuille.
Si vous sélectionnez un contrôle, puis décidez de ne plus le placer sur la feuille, cliquez sur l’outil
Sélection.
Contrôle Label
Le contrôle Label place un intitulé sur la feuille, généralement à côté d’un contrôle ne possédant
pas cet attribut (une zone de texte par exemple), pour aider l’utilisateur à en identifier la fonction.
Créer des interfaces utilisateur
Chapitre 13
327
Contrôle Label
Figure 13-5 – Le contrôle Label attache un libellé à un contrôle n’en possédant pas.
Contrôle TextBox
Le contrôle TextBox place une zone de texte sur la feuille, dans laquelle l’utilisateur pourra saisir
des informations. Les propriétés d’un TextBox permettent de contrôler le nombre maximal de
caractères que pourra entrer l’utilisateur, l’affichage sur plusieurs lignes du texte ou encore le
type d’alignement du texte. Elles sont étudiées au chapitre suivant.
Contrôle ComboBox
Le contrôle ComboBox, ou liste modifiable, insère une zone de texte permettant à l’utilisateur de
saisir une valeur manuellement ou de la sélectionner dans la liste qui se déroule lorsqu’il clique
Développer des interfaces utilisateur
328 Troisième partie
sur le bouton prévu à cet effet. Un contrôle ComboBox peut autoriser ou non l’utilisateur à saisir
une valeur ne figurant pas dans la liste.
Contrôle Frame
Le contrôle Frame place un cadre doté d’un intitulé sur une feuille, afin d’y placer des contrôles.
Il est généralement utilisé pour distinguer aisément les catégories de contrôles d’une feuille. Les
cadres servent aussi à associer des contrôles OptionButton (voir plus loin).
Contrôle ListBox
Le contrôle ListBox insère une liste déroulante d’options parmi lesquelles l’utilisateur doit choisir.
Les propriétés d’un ListBox permettent d’autoriser la sélection d’un seul ou de plusieurs éléments
de la liste. Lorsque la hauteur n’est pas suffisante pour afficher tous les éléments, une barre de
défilement verticale lui est associée.
Créer des interfaces utilisateur
Chapitre 13
329
Zones de liste
Figure 13-9 – Une zone de texte peut être associée à une liste déroulante afin d’en afficher la valeur sélectionnée.
Contrôle CheckBox
Un contrôle CheckBox, ou case à cocher, peut être activé (coché) ou désactivé (non coché) par
l’utilisateur, afin de valider ou non une option. Les propriétés d’un CheckBox permettent aussi
de lui faire accepter un troisième état, Null (ni coché, ni décoché) ; la case apparaît alors grisée.
Figure 13-10 – Les cases à cocher servent à valider ou non une option.
Développer des interfaces utilisateur
330 Troisième partie
Contrôle OptionButton
Les contrôles OptionButton proposent à l’utilisateur un choix parmi plusieurs options. Lorsque
plusieurs contrôles OptionButton sont associés, seul l’un d’eux peut être activé.
Contrôle ToggleButton
Le contrôle ToggleButton, ou bouton bascule, sert à l’utilisateur pour activer ou désactiver une
option, voire choisir l’état Null si les propriétés du contrôle l’y autorisent. Ce contrôle offre en
fait les mêmes fonctionnalités qu’une case à cocher, avec l’apparence d’un bouton de commande.
Lorsqu’un bouton bascule est activé, il semble enfoncé sur la feuille ; lorsqu’il est désactivé, il est
saillant ; à l’état Null, il apparaît estompé. La figure 13-12 présente les trois états possibles pour
un contrôle ToggleButton.
Figure 13-12 – Le contrôle ToggleButton est assez rarement utilisé dans les interfaces de programme.
Contrôle CommandButton
Le contrôle CommandButton est un bouton associé à une action. Il peut, par exemple, servir à
valider les informations entrées dans la feuille (bouton OK) afin de passer à l’étape suivante du
programme, ou au contraire interrompre le programme (bouton Annuler).
Créer des interfaces utilisateur
Chapitre 13
331
Figure 13-13 – Les boutons de commande figurent parmi les contrôles les plus courants.
Contrôle TabStrip
Le contrôle TabStrip, ou onglet, sert à créer une feuille dont l’affichage variera selon l’onglet
sélectionné. Tout se passe comme si l’accès à plusieurs feuilles était dirigé à partir d’une seule
feuille. Ce contrôle résout des problèmes d’espace en organisant les contrôles d’une feuille par
types, classés sous différents onglets. Lorsque l’utilisateur clique sur un onglet, les contrôles de
la feuille sont mis à jour par le code associé au contrôle.
Notez que les contrôles ne peuvent être associés à un onglet d’un TabStrip, ce dernier ne possédant
pas un espace propre à chaque onglet. Les contrôles sont placés sur la feuille et leur mise à jour liée
à la sélection d’un onglet ne peut être effectuée que par l’exécution du code précédemment écrit.
Contrôle MultiPage
Le contrôle MultiPage est semblable à TabStrip, en ce sens qu’il économise de l’espace en associant
différents affichages à une même feuille. À la différence de TabStrip, les pages constituant le
contrôle MultiPage sont autonomes de la feuille. Autrement dit, lorsque vous placez des contrôles
sur une page d’un contrôle MultiPage, ceux-ci ne s’afficheront que si la page en question est sélec-
tionnée. Vous n’aurez donc pas à écrire de code pour faire varier l’affichage de la feuille, mais
simplement à placer les contrôles voulus sur les pages constituant le contrôle.
Développer des interfaces utilisateur
332 Troisième partie
Figure 13-14 – Plusieurs contrôles MultiPage peuvent être placés sur une feuille,
chacun pouvant présenter un nombre variable d’onglets.
Contrôle ScrollBar
Le contrôle ScrollBar, ou barre de défilement, offre à l’utilisateur une zone lui permettant de se
déplacer dans un environnement. Une barre de défilement peut être horizontale ou verticale. Pour
déterminer sa position, redimensionnez-la en utilisant ses poignées de sélection. On se déplace à
l’aide d’une barre de défilement en cliquant sur l’une de ses touches fléchées ou à l’intérieur (entre
le curseur et l’une des flèches), ou encore par un glisser-déplacer du curseur.
Un contrôle ScrollBar est automatiquement affecté à un ListBox lorsque la hauteur de ce dernier
ne permet pas l’affichage de tous les éléments de la liste.
Contrôle
Figure 13-15 – Un contrôle ScrollBar permet ScrollBar de se déplacer
à l’utilisateur
dans une zone de texte trop petite pour afficher la totalité de son contenu.
Créer des interfaces utilisateur
Chapitre 13
333
Contrôle SpinButton
Un contrôle SpinButton, ou bouton toupie, est composé de deux flèches grâce auxquelles l’uti-
lisateur sélectionne une valeur. Les boutons toupies sont généralement associés à une zone de
texte dans laquelle s’affiche la valeur sélectionnée. Les propriétés de la zone de texte peuvent être
définies pour que l’utilisateur puisse y entrer une valeur saisie au clavier ou seulement à l’aide
du bouton toupie.
Figure 13-19 – Cette forme de pointeur indique que vous allez déplacer le contrôle.
Créer des interfaces utilisateur
Chapitre 13
335
Conseil
Dès que vous avez placé un contrôle sur une feuille, définissez sa propriété Name, qui correspond au nom
utilisé dans le code pour faire référence à ce contrôle.
Astuce
Pour accéder à la rubrique d’aide Visual Basic d’un contrôle, sélectionnez ce dernier sur la feuille et tapez
sur la touche F1.
Ce chapitre traite du développement de feuilles VBA. De la même façon, des contrôles peuvent
être placés sur une feuille de calcul Excel. Les procédures pour les exploiter sont les mêmes que
pour une feuille UserForm développée dans Visual Basic Editor ; elles sont stockées dans l’objet
Feuille portant le nom de la feuille, situé dans le module Objets Microsoft Excel.
Pour placer des contrôles sur une feuille de calcul plutôt que sur une feuille UserForm, affichez
la barre d’outils Visual Basic dans Excel et cliquez sur le bouton Création, puis sur Boîte à outils
Contrôles. Pour quitter ce mode, cliquez à nouveau sur le bouton Création.
Astuce
Pour copier-coller un contrôle, vous pouvez aussi cliquer-droit dessus et, tout en maintenant le bouton de
la souris enfoncé, le faire glisser à l’endroit où vous souhaitez en placer une copie. Relâchez ensuite le
bouton de la souris et, dans le menu contextuel qui s’affiche, sélectionnez Copier ici.
Développer des interfaces utilisateur
336 Troisième partie
Figure 13-21 – Vous pouvez aussi placer des contrôles sur une feuille de calcul Excel.
Info
Lorsque vous sélectionnez plusieurs contrôles, les poignées de sélection de l’un d’eux apparaissent en
blanc (celles des autres sont noires). Il s’agit du contrôle actif. Cette notion est particulièrement utile pour
mettre en forme vos feuilles. Vous pouvez ainsi appliquer certaines propriétés du contrôle actif – telles que
sa taille ou sa position – aux autres sélectionnés.
La grille
La grille désigne les points quadrillant une feuille dans une fenêtre UserForm, qui n’apparaissent
qu’en phase de conception et ont pour fonction de faciliter la mise en place des contrôles.
Développer des interfaces utilisateur
338 Troisième partie
Lorsque l’alignement sur la grille est activé, l’angle supérieur gauche des contrôles est automa-
tiquement placé sur le point de la grille le plus proche. Les contrôles acceptent alors autant de
positions qu’il existe de points de quadrillage sur la feuille.
1. Sélectionnez la commande Options du menu Outils de Visual Basic Editor et activez la page
Général de la boîte de dialogue qui s’affiche. La zone Paramètres de grille de la feuille (voir
figure 13-25) sert à définir les options.
2. Cochez les cases Afficher la grille afin de faire apparaître les points de quadrillage sur la feuille,
puis déterminez la précision de la grille en spécifiant des valeurs de largeur et de hauteur.
3. Cochez la case Aligner les contrôles sur la grille, puis cliquez sur OK.
Info
La commande Ajuster à la grille du menu Format ajuste la hauteur et la largeur des contrôles sélectionnés
aux lignes de grille les plus proches.
Astuce
Pour modifier le contrôle actif d’une sélection, maintenez la touche Ctrl enfoncée et cliquez à deux reprises
sur celui que vous souhaitez.
2. Choisissez la commande Aligner du menu Format ou cliquez sur la flèche du bouton Aligner
de la barre d’outils UserForm (voir figure 13-27).
3. Choisissez l’alignement voulu parmi les sept proposés.
Toute la sélection s’aligne sur le contrôle actif.
Info
Un mauvais choix peut entraîner la juxtaposition des contrôles. Cliquez alors sur le bouton Annuler de la
barre d’outils Standard ou tapez le raccourci Ctrl+Z pour ramener les contrôles à leur position précédente.
Figure 13-29 – Une même largeur et une même hauteur ont été affectées aux contrôles sélectionnés.
Astuce
Vous pouvez adapter la taille d’un contrôle à son contenu en choisissant la commande Ajuster la taille du
menu Format.
Astuce
Vous pouvez adapter la taille d’un contrôle à son contenu en choisissant la commande Ajuster la taille du
menu Format.
Créer des interfaces utilisateur
Chapitre 13
341
Figure 13-30 – Un même espacement vertical a été appliqué aux contrôles sélectionnés.
Figure 13-31 – Les contrôles ont été centrés horizontalement sur la feuille.
Développer des interfaces utilisateur
342 Troisième partie
Info
Si des contrôles autres que des boutons de commande sont sélectionnés, ils ne seront pas affectés par la
commande Réorganiser les boutons. Si des contrôles occupent déjà l’espace vers lequel sont envoyés les
boutons, ces derniers les recouvriront.
Info
On ne peut sélectionner qu’un contrôle à la fois à l’intérieur d’un groupe. Déterminez la mise en forme des
contrôles avant de les grouper.
Ajouter/supprimer un contrôle
Dans cet exemple, nous ajouterons le contrôle Calendar dans la boîte à outils. Comme il n’est plus
livré avec les dernières versions d’Office, nous le fournissons avec les codes du livre, en télé-
chargement sur le site d’Eyrolles (http://www.editions-eyrolles.com/dl/0067786). Si vous n’avez
pas encore téléchargé les codes sources, commencez par le faire. Référencez ensuite le contrôle
Calendrier. Procédez comme suit :
1. Placez le fichier mscal.ocx (situé dans le dossier Bonus des codes sources du livre) dans le
dossier C:\Windows\System32.
Développer des interfaces utilisateur
344 Troisième partie
2. Enregistrez le contrôle ActiveX dans la base de registre : lancez l’application Invite de com-
mandes en mode administrateur (cliquez droit sur le nom de l’application et choisissez Exécuter
en tant qu’administrateur), puis saisissez la commande :
regsvr32 mscal.ocx
Tapez sur la touche Entrée. Un message vous informe que l’enregistrement a réussi.
3. Activez l’onglet Développeur du ruban d’Excel.
4. Cliquez sur le bouton Insérer du groupe Code, puis sur le bouton Autres contrôles (voir
figure 13-34)
5. Dans la boîte de dialogue qui s’affiche, cliquez sur le bouton Enregistrer le contrôle person-
nalisé. Localisez le fichier mscal.ocx, puis validez.
Le contrôle Calendrier apparaît maintenant dans la boîte de dialogue Autres contrôles (voir
figure 13-35).
Pour ajouter le contrôle Calendrier à la boîte à outils, ouvrez Visual Basic Editor et procédez
comme suit :
1. Activez une feuille Userform, puis affichez la boîte à outils. Cliquez-droit sur celle-ci et
sélectionnez la commande Contrôles supplémentaires du menu contextuel ou choisissez la
commande Contrôles supplémentaires du menu Outils (voir figure 13-36). Les contrôles qui
peuvent être exploités et placés sur la boîte à outils s’affichent.
2. Pour ajouter/supprimer un contrôle dans la boîte à outils, cochez/décochez sa case. Ici, cochez
la case intitulée Contrôle Calendrier.
3. Cliquez sur OK. Le contrôle Calendrier est maintenant disponible dans la boîte à outils (voir
figure 13-37).
5. Vous pouvez :
– modifier le texte de l’info-bulle ;
– modifier l’image représentant le contrôle sur la boîte à outils, en chargeant un fichier (bouton
Charger une image) ou en la dessinant (Éditer une image).
Astuce
Pour supprimer des contrôles à partir de la boîte de dialogues Contrôles supplémentaires, cochez la case
Afficher éléments sélectionnés seulement. Seuls les contrôles disponibles sur la boîte à outils seront pro-
posés. Décochez alors ceux que vous souhaitez supprimer.
Vous pouvez aussi supprimer un contrôle à partir de la boîte à outils. Cliquez-droit dessus et sélectionnez
la commande Supprimer contrôle.
La figure 13-39 présente une feuille sur laquelle un contrôle Calendar a été placé.
Info
L’outil Sélection est toujours présent sur les pages de la boîte à outils et ne peut être supprimé.
Créer des interfaces utilisateur
Chapitre 13
347
2. Cliquez-droit sur l’onglet et choisissez la commande qui Renommer s’affiche (voir figure 13-41).
Indiquez le nom de la page et, éventuellement, le texte d’info-bulle. Cliquez sur OK.
Développer des interfaces utilisateur
348 Troisième partie
3. Pour ajouter ou supprimer des contrôles sur la nouvelle page, activez-la, puis procédez comme
indiqué dans la section précédente.
4. Si vous souhaitez modifier l’emplacement de l’onglet sur la boîte à outils, cliquez dessus et
sélectionnez la commande Déplacer. Utilisez les boutons Vers le haut et Vers le bas de la boîte
de dialogue Ordre des pages (voir figure 13-42).
Figure 13-42 – L’emplacement des onglets de la boîte à outils se détermine dans cette boîte de dialogue.
Pour supprimer une page, cliquez-droit sur son onglet et choisissez la commande Supprimer la
page.
La procédure suivante affiche une boîte de dialogue invitant l’utilisateur à indiquer s’il souhaite
que l’interface soit affichée. Si la réponse est positive, MaFeuille s’affiche. Dans le cas contraire,
le programme se poursuit avec la procédure SuiteDuProgramme.
Créer des interfaces utilisateur
Chapitre 13
349
Sub AffichageFeuille()
Dim RepAffichage As Integer
RepAffichage = MsgBox("Souhaitez-vous afficher le formulaire ?", _
vbYesNo + vbQuestion, "Affichage de feuille")
If RepAffichage=vbYes Then
MaFeuille.Show
Else
Call SuiteDuProgramme
End If
End Sub
Pour masquer une feuille, on lui applique la méthode Hide, selon la syntaxe suivante :
NomFeuille.Hide
Cette instruction est généralement placée dans la procédure événementielle affectée au bouton de
validation de la feuille. Les valeurs entrées par l’utilisateur sont alors passées à une autre procédure
qui les exploitera et la feuille est masquée. Dans l’exemple suivant, lorsque l’utilisateur clique sur
le bouton cmdOK de MaFeuille, celle-ci est masquée et la procédure SuiteDuProgramme est appelée.
Private Sub cmdOK_Click()
MaFeuille.Hide
Call SuiteDuProgramme(arg1, arg2, …, argN)
End Sub
Astuce
La propriété Me renvoie la feuille active. Elle peut être utilisée dans n’importe quelle procédure événemen-
tielle attachée à une feuille pour la manipuler.
Si c’est la feuille active que vous souhaitez masquer (l’objet conteneur du contrôle ayant reçu l’événement),
utilisez le mot-clé Me à la place de la propriété Name de la feuille (Me.Hide).
Info
L’affectation de procédures événementielles aux contrôles est traitée aux chapitres 13 et 14.
14
Exploiter les propriétés
des contrôles
Au cours des chapitres précédents, vous avez découvert les différents contrôles disponibles et
les outils destinés à leur mise en forme. Vous savez donc créer des formulaires à l’apparence
professionnelle, mais ce ne sont pour l’instant que des feuilles sans vie. Ce chapitre et le suivant
vous montrent comment tirer parti des feuilles VBA en exploitant les propriétés des contrôles et
en associant du code aux événements les affectant.
En tant qu’objets, les feuilles et les contrôles possèdent un certain nombre de propriétés qui en
déterminent l’apparence et le comportement. Il est fortement recommandé de préciser la propriété
Name des contrôles au fur et à mesure que vous les placez sur la feuille.
Sélectionnez un objet et tapez sur la touche F4 afin d’en ouvrir la fenêtre Propriétés, ou cliquez-
droit et sélectionnez la commande Propriétés du menu contextuel. Affectez ensuite les valeurs
voulues à l’objet. Reportez-vous à la section « La fenêtre Propriétés » du chapitre 4.
Astuce
Si vous sélectionnez plusieurs contrôles sur la feuille, la fenêtre Propriétés affiche alors les propriétés
qui leur sont communes. Les modifications que vous apporterez seront appliquées à tous les contrôles
sélectionnés.
Il existe évidemment des propriétés spécifiques pour chaque contrôle et d’autres communes à
presque tous. Les sections qui suivent vous présentent les propriétés essentielles, classées par
catégories.
Développer des interfaces utilisateur
352 Troisième partie
Dans la réalité, vous ne modifierez que très peu d’entre elles, car la valeur par défaut est le plus
souvent satisfaisante. Les propriétés que vous devez connaître et que vous serez amené à utiliser
présentent une icône en marge, identique à celle qui se trouve en marge de ce paragraphe.
Astuce
Sélectionnez le nom d’une propriété et tapez sur la touche F1 pour obtenir de l’aide. Vous pouvez aussi
sélectionner le contrôle sur la feuille, puis taper sur F1 pour ouvrir la rubrique d’aide associée (voir
figure 14-1).
Figure 14-1 – Accédez en un clin d’œil aux rubriques d’aide des propriétés d’un contrôle.
Propriété Name
La propriété Name est exploitée par le programme et reste invisible à l’utilisateur final. Elle corres-
pond au nom de l’objet et est de type String (chaîne de caractères). Ce nom est utilisé pour faire
référence à l’objet dans le code, par exemple pour connaître ou modifier l’une de ses propriétés.
Un même nom ne peut être utilisé pour plusieurs objets d’une même feuille.
Lorsque vous placez un contrôle sur une feuille, sa propriété Name est par défaut une chaîne com-
posée du nom de la classe de l’objet suivi d’un nombre entier. Par exemple, lorsque vous placez
Exploiter les propriétés des contrôles
Chapitre 14
353
un bouton d’option, sa propriété Name est définie à OptionButton1, OptionButton2 s’il existe déjà
un contrôle OptionButton1, etc.
Conseil
Affectez des noms représentatifs aux contrôles de votre feuille. Il vous sera ainsi facile de savoir à quel
contrôle fait référence une instruction dans le code.
L’instruction If…End If suivante teste la propriété Value d’une zone de texte (le texte saisi par
l’utilisateur) dont la propriété Name est définie à txtMotDePasse. Si elle ne contient aucune infor-
mation, un message demande à l’utilisateur d’entrer un mot de passe.
If txtMotDePasse.Value="" Then
MsgBox "Vous devez indiquer un mot de passe.", VBOKOnly, "Mot de passe requis"
End If
Astuce
Si une zone de texte est destinée à recevoir un mot de passe, affectez un caractère tel que l’astérisque à sa
propriété PasswordChar, afin qu’il s’affiche à la place des caractères saisis par l’utilisateur.
Vous devrez aussi protéger votre projet, afin que l’utilisateur ne puisse accéder au code de la procédure
pour y lire le mot de passe : cliquez-droit sur le projet dans la fenêtre Propriétés et choisissez la commande
Propriétés de NomProjet. Activez l’onglet Protection et cochez la case Verrouiller le projet pour l’affichage.
Saisissez ensuite un mot de passe dans la zone de texte appropriée. Cette protection prendra effet lors du
prochain lancement d’Excel.
Figure 14-2 – Pour faire référence à un contrôle dans le code, utilisez sa propriété Name.
Apparence
Alignment
Cette propriété détermine la position d’un contrôle CheckBox ou OptionButton par rapport à sa
légende (Caption). Elle prend pour valeur l’une des constantes fmalignment :
• fmalignmentright (par défaut) place le libellé à droite du contrôle.
• fmalignmentleft le place à gauche.
Développer des interfaces utilisateur
354 Troisième partie
BackStyle
Cette propriété détermine le style de fond du contrôle. Elle prend pour valeur l’une des constantes
fmBackStyle :
• fmBackStyleOpaque (par défaut) détermine un fond opaque. Les éventuels objets placés à l’ar-
rière-plan de l’objet sont invisibles.
• fmBackStyleTransparent détermine un fond transparent. Les éventuels objets placés à l’arrière-
plan de l’objet sont visibles.
BackColor
Cette propriété prend pour valeur une variable de type Long représentant la couleur de fond du
contrôle. Lorsque vous modifiez sa valeur dans la fenêtre Propriétés, vous pouvez sélectionner
une couleur sur l’onglet Palette (voir figure 14-4) ou sur l’onglet Système.
Si la propriété BackStyle est définie sur fmBackStyleTransparent, Color est sans effet sur l’appa-
rence du contrôle.
Figure 14-4 – Sélectionnez une couleur de fond pour le contrôle dans cette palette.
Exploiter les propriétés des contrôles
Chapitre 14
355
BorderStyle
Cette propriété détermine l’affichage ou non d’une bordure pour le contrôle. Elle prend pour
valeur l’une des constantes fmBorderStyle :
• fmBorderStyleNone indique qu’aucune bordure ne s’affiche pour le contrôle.
• fmBorderStyleSingle indique qu’une bordure s’affiche.
BorderColor
Cette propriété détermine la couleur du contour du contrôle et peut prendre les mêmes valeurs
que BackColor.
Si la propriété BorderStyle est définie sur fmBorderStyleNone, BorderColor est sans effet sur l’appa-
rence du contrôle.
Caption
La propriété Caption détermine le texte descriptif d’un contrôle et accepte une valeur de type
String. Son emplacement varie selon le contrôle. Par exemple, le libellé d’un bouton de commande
est centré sur le contrôle, tandis que celui d’une case à cocher ou d’un bouton d’option peut être
aligné à droite (par défaut) ou à gauche, selon la valeur de la propriété Alignment. La figure 14-5
présente deux boutons de commande dont les propriétés Caption ont été définies à OK et à Annuler.
Il peut être utile de faire varier la propriété Caption d’un contrôle en fonction des événements.
Dans l’exemple suivant, lorsque l’utilisateur clique sur le bouton de commande dont Name est
«JoueurSuivant», la propriété Caption de MonLibellé bascule entre «Joueur 1» et «Joueur 2».
Private Sub JoueurSuivant_Click()
Call AutreProcédure
If MonLibellé.Caption="Joueur 1" Then
MonLibellé.Caption = "Joueur 2"
Else
MonLibellé.Caption = "Joueur 1"
End If
End Sub
Sub AutreProcédure()
Instructions
End Sub
Développer des interfaces utilisateur
356 Troisième partie
La première ligne appelle une procédure d’événement (traitée au chapitre suivant) lorsque l’uti-
lisateur clique sur le bouton dont la propriété Name est «JoueurSuivant». Les Instructions de
AutreProcédure s’exécutent, puis la procédure appelante reprend la main. Enfin, l’instruction If…
End If modifie la propriété Caption de MonLibellé : si elle vaut «Joueur 1», elle est redéfinie à
«Joueur 2» et inversement.
Attention
Ne confondez pas le libellé d’un contrôle (Caption) et son nom (Name). Le nom sert à faire référence à ce
contrôle dans le code du programme et est invisible pour l’utilisateur final.
ControlTipText
Cette propriété détermine le texte de l’info-bulle qui s’affiche lorsque l’utilisateur place le pointeur
au-dessus du contrôle sans cliquer. Elle accepte une valeur de type String et contient par défaut
une chaîne vide. N’hésitez pas à utiliser cette propriété pour décrire brièvement à l’utilisateur la
fonction des contrôles d’une feuille (figure 14-6).
ForeColor
Cette propriété détermine la couleur de premier plan du contrôle, pour l’affichage de sa propriété
Caption.
SpecialEffect
Cette propriété détermine l’apparence du contrôle sur la feuille.
Les contrôles CheckBox, RadioButton et ToggleButton acceptent l’une des constantes suivantes :
• fmButtonEffectFalt ;
• fmButtonEffectSunken.
Exploiter les propriétés des contrôles
Chapitre 14
357
Style
Cette propriété détermine la façon dont la sélection s’effectue dans un contrôle ComboBox : l’utili-
sateur peut ou non être autorisé à saisir une valeur ne figurant pas dans la liste. Elle accepte pour
valeur l’une des deux constantes fmStyle suivantes :
• fmStyleDropDownCombo (par défaut). L’utilisateur peut sélectionner un item dans la liste dérou-
lante ou saisir manuellement une valeur de son choix. C’est, par exemple, le cas de la liste
Zoom de la barre d’outils Standard d’Excel.
• fmStyleDropDownList. Les seules valeurs autorisées sont celles de la liste attachée au contrôle.
Lorsque l’utilisateur saisit un caractère au clavier, le premier élément de la liste commençant
par ce caractère est sélectionné. Si aucun élément de la liste ne correspond, la valeur du
contrôle reste inchangée.
Utilisez un contrôle ComboBox dont la propriété Style est définie à fmStyleDropDownList, plutôt
qu’un ListBox, pour réduire l’espace occupé sur la feuille.
Attention
Lorsque vous autorisez la saisie manuelle dans la zone d’édition d’un contrôle ComboBox, assurez-vous
que l’utilisateur ne pourra y entrer une valeur non valide, qui générerait une erreur ou aboutirait à un mau-
vais fonctionnement du programme. Affectez pour cela une procédure à l’événement Change du contrôle,
qui contrôlera la valeur saisie (voir l’exemple donné pour le contrôle TextBox, au chapitre suivant).
Value
Cette propriété détermine la valeur d’un contrôle, qui peut correspondre à un état (le fait qu’une
case soit ou non cochée : valeur numérique) ou à un contenu (le texte saisi dans la zone d’édition
d’une zone de texte : type String).
Le tableau suivant présente les valeurs acceptées par la propriété Value des contrôles standards.
Développer des interfaces utilisateur
358 Troisième partie
La procédure suivante se déclenche lorsque l’utilisateur clique sur le bouton de commande btnOK.
Elle teste la valeur de la propriété Value du contrôle txtMotdePasse, une zone de texte dans laquelle
l’utilisateur est invité à saisir son mot de passe. Si elle est égale à une chaîne vide, la boîte de
dialogue de la figure 14-7 s’affiche.
If txtMotDePasse.Value="" Then
MsgBox "Vous devez indiquer un mot de passe.", VBOKOnly, "Mot de passe requis"
Else
Instructions
End If
Figure 14-7 – Value est l’une des propriétés les plus utilisées.
Exploiter les propriétés des contrôles
Chapitre 14
359
Visible
Cette propriété détermine la visibilité d’un contrôle pour l’utilisateur. Elle accepte une valeur
de type Boolean :
• True (par défaut) indique que le contrôle est visible.
• False indique que le contrôle est masqué et n’apparaît pas sur la feuille.
Info
La propriété Visible d’un contrôle n’influe pas sur son apparence durant la phase de conception.
Le contrôle est toujours visible dans Visual Basic Editor.
La propriété Visible permet d’élaborer des feuilles dont l’apparence et les fonctionnalités varie-
ront selon le contexte. Vous pouvez ainsi n’afficher les contrôles d’une feuille que s’ils doivent
être renseignés par l’utilisateur. La figure 14-8 présente la feuille Nouveau salarié, en phase de
conception dans Visual Basic Editor.
Outre le sexe et la situation, l’utilisateur est invité à entrer un prénom et un nom. Une zone de
texte sert à indiquer un éventuel nom de jeune fille.
Les propriétés des contrôles OptionButton, CheckBox et Label de la feuille ont été définies comme
suit :
Propriété Name Propriété Caption
Contrôles OptionButton
optMasculin Masculin
optFéminin Féminin
optMarié Marié(e)
optCélibataire Célibataire
optMaritale Vie maritale
Développer des interfaces utilisateur
360 Troisième partie
Il est évidemment inutile d’afficher le libellé Nom de jeune fille et la zone de texte correspondante
si les boutons d’option Féminin et Marié(e) ne sont pas tous deux cochés. Leur propriété Visible
a donc été définie à False – la propriété Value du contrôle optMasculin étant définie à True afin
que ce bouton soit coché par défaut. Le code suivant affiche les contrôles txtNomJF et lbJF lorsque
cela est nécessaire et les masque dans le cas contraire.
Private Sub optFéminin_Click()
If optMarié.Value=True Then
txtNomJF.Visible = True
lbJF.Visible = True
Else
txtNomJF.Visible = False
lbJF.Visible = False
End If
End Sub
Private Sub optMarié_Click()
If optFéminin.Value=True Then
txtNomJF.Visible = True
lbJF.Visible = True
Else
txtNomJF.Visible = False
lbJF.Visible = False
End If
End Sub
Private Sub optMasculin_Click()
txtNomJF.Visible = False
lbJF.Visible = False
End Sub
Private Sub optCélibataire_Click()
txtNomJF.Visible = False
lbJF.Visible = False
End Sub
Exploiter les propriétés des contrôles
Chapitre 14
361
Private Sub optMaritale_Click()
txtNomJF.Visible = False
lbJF.Visible = False
End Sub
Comportement
AutoSize
Cette propriété spécifie si un contrôle se redimensionne automatiquement pour afficher son
contenu, c’est-à-dire la valeur de sa propriété Caption ou, dans le cas d’un TextBox ou d’un ComboBox,
le texte qui apparaît dans sa zone d’édition. La propriété AutoSize accepte une valeur de type
Boolean :
• True. Le contrôle se redimensionne automatiquement.
• False (par défaut). La taille du contrôle est fixe.
Info
Lorsque vous définissez la propriété AutoSize d’un contrôle durant la phase de conception, il se redimen-
sionne automatiquement en fonction de son contenu. Si vous le souhaitez, définissez une taille supérieure.
En phase d’exécution, le contrôle conservera la taille ainsi définie, tant que celle-ci suffira à afficher tout
le contenu.
Développer des interfaces utilisateur
362 Troisième partie
La figure 14-10 présente deux TextBox dont les propriétés AutoSize sont respectivement définies sur
True et False. L’un s’est redimensionné automatiquement, tandis que le texte du second est rogné.
Conseil
Ne définissez la propriété AutoSize d’un contrôle TextBox sur True que si le nombre de caractères auto-
risés dans ce contrôle (propriété MaxLength) est limité. Dans le cas contraire, l’utilisateur pourrait saisir un
nombre illimité de caractères et le contrôle dépasserait les limites de la feuille.
AutoTab
Disponible pour les contrôles TextBox et ComboBox dont la propriété MaxLength a été définie, AutoTab
spécifie si une tabulation automatique se déclenche lorsque le nombre maximal de caractères est
atteint. Si tel est le cas, le focus est passé au contrôle suivant dans l’ordre de tabulation.
Info
Le contrôle qui a le focus est réceptif aux événements utilisateur (souris ou clavier). Un seul peut avoir le
focus à un moment donné et le type d’événements reconnus varie d’un contrôle à l’autre.
Par exemple, taper sur la touche Entrée alors qu’un bouton de commande a le focus revient à cliquer sur ce
bouton. Cela n’aura en revanche aucun effet si le focus correspond à une case à cocher, alors que chaque
frappe de la touche Tab la fera passer d’un état à l’autre.
Définition
L’ordre de tabulation désigne l’ordre dans lequel le focus est transmis aux différents contrôles d’une feuille
et est déterminé par leur propriété TabIndex.
Exploiter les propriétés des contrôles
Chapitre 14
363
AutoWordSelect
Cette propriété détermine la façon dont le texte est sélectionné dans la zone d’édition d’un contrôle
TextBox ou ComboBox. L’unité de sélection peut être le mot ou le caractère. AutoWordSelect accepte
une valeur de type Boolean :
• True (par défaut). La sélection se fait mot par mot au-delà du premier mot.
• False. La sélection se fait caractère par caractère, quelle que soit son étendue.
Cancel
Cette propriété spécifie si un contrôle CommandButton est ou non le bouton Annuler de la feuille.
Lorsque c’est le cas, la frappe de la touche Échap déclenche l’événement Click du bouton, qu’il
ait ou non le focus. Outre cet accès, le bouton est toujours activable par les méthodes classiques
– raccourci clavier, clic de souris ou touche Entrée lorsque le contrôle a le focus. Cancel accepte
une valeur de type Boolean :
• True. Le bouton de commande est le bouton Annuler de la feuille.
• False (par défaut). Il n’est pas le bouton Annuler.
Dans le cas d’une procédure complexe, ou nécessitant un grand nombre d’opérations de la part
de l’utilisateur, protégez l’activation du bouton d’annulation en affichant une boîte de dialogue
demandant la confirmation de l’abandon.
La procédure suivante affiche la boîte de dialogue présentée à la figure 14-11 lorsque l’utilisateur
clique sur le bouton de commande cmdAnnuler.
Private Sub cmdAnnuler_Click()
Dim Confirm As Single
Confirm = MsgBox("Si vous annulez la procédure, vous perdrez toutes les données
➥ entrées. " _
& "Etes-vous sûr de vouloir annuler ?", vbYesNo + vbCritical, "Abandon de la
➥ procédure")
If Confirm=vbYes Then
Exit Sub
End If
End Sub
Développer des interfaces utilisateur
364 Troisième partie
Info
Sur une même feuille, il ne peut y avoir qu’un seul bouton Annuler. Lorsque vous définissez la propriété
Cancel d’un bouton de commande sur True, elle est automatiquement définie à False pour tous les autres.
Default
Cette propriété spécifie si un contrôle CommandButton est ou non le bouton par défaut de la feuille.
Lorsque c’est le cas, la frappe de la touche Entrée déclenche l’événement Click du bouton, à condi-
tion qu’il ait le focus. Outre cet accès, le bouton est toujours activable par les méthodes classiques
– raccourci clavier, clic de souris. Default accepte une valeur de type Boolean :
• True. Le bouton de commande est celui par défaut.
• False (par défaut). Il n’est pas le bouton par défaut.
Info
Sur une même feuille, il ne peut y avoir qu’un seul bouton par défaut. Lorsque vous définissez la propriété
Default d’un bouton de commande sur True, elle est automatiquement définie à False pour tous les
autres.
Enabled
Cette propriété détermine si un contrôle est accessible, c’est-à-dire qu’il peut avoir le focus, ou
inaccessible, auquel cas il apparaît estompé et l’utilisateur ne peut le sélectionner ni à l’aide de
la souris ni à l’aide de la touche Tab. Enabled accepte une valeur de type Boolean :
• True (par défaut). Le contrôle est accessible.
• False. Il n’est pas accessible.
Utilisez cette propriété pour déterminer l’accessibilité d’un contrôle en fonction du contexte. Dans
l’exemple suivant, nous avons ajouté un CheckBox sur la feuille, afin d’indiquer si le nouveau salarié
est dégagé ou non des obligations militaires – sa propriété Name a été définie à chkMilitaire. Il
Exploiter les propriétés des contrôles
Chapitre 14
365
est inutile que l’utilisateur accède à ce contrôle si le nouveau salarié est une femme. Nous avons
ajouté deux instructions dans ce sens.
Private Sub optFéminin_Click()
If optMarié.Value=True Then
txtNomJF.Visible = True
lbJF.Visible = True
Else
txtNomJF.Visible = False
lbJF.Visible = False
End If
chkMilitaire.Enabled = False
End Sub
Private Sub optMarié_Click()
If optFéminin.Value=True Then
txtNomJF.Visible = True
lbJF.Visible = True
Else
txtNomJF.Visible = False
lbJF.Visible = False
End If
End Sub
Private Sub optMasculin_Click()
txtNomJF.Visible = False
lbJF.Visible = False
chkMilitaire.Enabled = True
End Sub
Private Sub optCélibataire_Click()
txtNomJF.Visible = False
lbJF.Visible = False
End Sub
Private Sub optMaritale_Click()
txtNomJF.Visible = False
lbJF.Visible = False
End Sub
Info
Notez qu’un contrôle peut être accessible et non modifiable. Pour plus de précisions, voyez la propriété
Locked.
Développer des interfaces utilisateur
366 Troisième partie
Figure 14-12 – La propriété Enabled détermine l’accessibilité d’un contrôle en fonction du contexte.
EnterKeyBehavior
Cette propriété détermine le comportement d’un contrôle CheckBox lorsque l’utilisateur appuie
sur la touche Entrée. Elle accepte une valeur de type Boolean :
• True. Une pression sur la touche Entrée crée une nouvelle ligne.
• False (par défaut). Une pression sur la touche Entrée passe le focus au contrôle suivant dans
l’ordre de tabulation.
Info
Si la propriété MultiLine d’un CheckBox est définie sur False, le contrôle n’autorise qu’une ligne et une
pression sur la touche Entrée entraînera toujours le passage du focus au contrôle suivant dans l’ordre de
tabulation.
HideSelection
Cette propriété détermine si la sélection dans un TextBox ou un ComboBox demeure ou non visible
lorsque le contrôle n’a pas le focus. Elle accepte une valeur de type Boolean :
• True (par défaut). La sélection n’est visible que lorsque le contrôle a le focus.
• False. La sélection demeure visible, que le contrôle ait le focus ou non.
Maintenir la sélection visible dans un TextBox ou un ComboBox lorsque celui-ci n’a pas le focus
est déroutant pour l’utilisateur, car cette propriété est généralement spécifique du contrôle ayant
le focus.
Exploiter les propriétés des contrôles
Chapitre 14
367
Locked
Cette propriété détermine si un contrôle peut ou non être modifié ou activé par l’utilisateur. Elle
accepte une valeur de type Boolean :
• True. Le contrôle peut être modifié.
• False (par défaut). Il n’est pas modifiable.
Conseil
Utilisez Locked conjointement avec Enabled, par exemple pour laisser l’utilisateur copier le contenu d’une
zone de texte sans l’autoriser à le modifier.
Locked doit être définie sur True pour un contrôle ayant une fonction de consultation ; par exemple,
un TextBox affichant le texte sélectionné dans le document ou le résultat d’un calcul.
Info
Lorsque la propriété Locked est définie à True, le contenu du contrôle n’est pas modifiable directement
sur la feuille durant la phase Conception. Si vous souhaitez modifier sa propriété Caption ou Value, vous
devez le faire dans la fenêtre Propriétés.
MaxLength
Cette propriété spécifie le nombre maximal de caractères que l’utilisateur est autorisé à saisir dans
un TextBox ou un ComboBox. Elle accepte une valeur de type Integer. Par défaut, elle est définie
sur 0, l’utilisateur étant alors autorisé à entrer un nombre de caractères indéterminé.
Lorsque le nombre maximal de caractères est atteint, les frappes de clavier restent sans effet.
Vous pouvez aussi choisir que le focus soit passé au contrôle suivant dans l’ordre de tabulation
en définissant la propriété AutoTab sur True.
Conseil
Affectez une valeur MaxLength aux TextBox destinés à recevoir un nombre de caractères constant (mot
de passe ou code produit, par exemple), ou lorsque la limitation est une nécessité du programme.
MultiLine
Cette propriété détermine si le texte saisi dans un TextBox s’affiche sur la ligne suivante lorsqu’il
arrive en bout de ligne. Si tel est le cas, le texte s’affiche sur la ligne suivante tant que les dimen-
sions du contrôle le permettent. MultiLine accepte une valeur de type Boolean :
• True (par défaut). Le texte s’affiche sur plusieurs lignes lorsque cela est nécessaire.
• False. Il s’affiche sur une seule ligne.
Développer des interfaces utilisateur
368 Troisième partie
SelectionMargin
Cette propriété détermine si l’utilisateur peut ou non sélectionner une ligne de texte dans un
TextBox ou un ComboBox avec le curseur. Si tel est le cas, le curseur se transforme en flèche lorsqu’il
est placé à gauche de la ligne à sélectionner (voir figure 14-13). SelectionMargin accepte une
valeur de type Boolean :
• True (par défaut). Ce type de sélection est possible.
• False. Ce type de sélection est impossible.
Style
Cette propriété détermine si un ComboBox autorise ou non la saisie d’une valeur ne figurant pas
dans sa liste déroulante. Style accepte pour valeur une constante fmStyle :
• fmStyleDropDownCombo (par défaut). Le contrôle se comporte comme une zone de texte.
L’utilisateur peut saisir une valeur de son choix dans la zone d’édition ou sélectionner l’une
des options de la liste déroulante. Si les premières lettres saisies sont rapprochées de l’une de
ces options, le complément automatique est proposé. L’utilisateur doit alors accepter le com-
plément proposé ou saisir une valeur différente.
• fmStyleDropDownList. L’utilisateur ne peut sélectionner qu’une des options de la liste. Il est
impossible de saisir une valeur différente dans la zone d’édition du contrôle. Si l’utilisateur
saisit une lettre au clavier alors que le contrôle a le focus, l’option la plus proche de la lettre
saisie est sélectionnée.
Info
La façon dont le rapprochement est effectué entre la valeur saisie par l’utilisateur dans la zone d’édition et
les options de la liste est déterminée par les propriétés MatchEntry et MatchRequired du contrôle.
Exploiter les propriétés des contrôles
Chapitre 14
369
TabKeyBehavior
Cette propriété détermine si l’utilisateur peut ou non saisir une tabulation dans la zone d’édition
d’un TextBox. Elle accepte une valeur de type Boolean :
• True. L’utilisateur peut saisir une tabulation dans la zone d’édition. La touche Tab n’est donc
pas utilisable pour passer le focus au contrôle suivant dans l’ordre de tabulation.
• False (par défaut). La touche Tab entraîne le passage du focus au contrôle suivant.
Conseil
Ne définissez cette propriété sur True que si l’exploitation des données du contrôle par le programme
prévoit la gestion des tabulations.
TextAlign
Cette propriété détermine la façon dont est aligné le libellé d’un Label ou le texte dans un TextBox
ou un ComboBox. Elle accepte l’une des trois constantes fmTextAlign :
• fmTextAlignLeft (par défaut). Aligné à gauche.
• fmTextAlignCenter. Centré.
• fmTextAlignRight. Aligné à droite.
Info
Dans le cas d’un ComboBox, TextAlign ne détermine que l’alignement du texte saisi dans la zone d’édition
et non les entrées de la liste, qui sont toujours alignées à gauche.
TripleState
Cette propriété détermine si un contrôle OptionButton, CheckBox ou ToggleButton autorise ou non
l’état Null (ni activé ni désactivé). Une case à cocher ou un bouton d’option à l’état Null apparaît
estompé et contient une marque d’activation (voir figure 14-14). Sa propriété Value renvoie alors
la valeur Null. Lorsqu’un bouton bascule à l’état Null, son libellé apparaît estompé. TripleState
accepte une valeur de type Boolean :
• True. Le contrôle accepte l’état Null.
• False (par défaut). Le contrôle n’accepte que les états activé et désactivé.
Développer des interfaces utilisateur
370 Troisième partie
WordWrap
Cette propriété détermine si un contrôle autorise un changement de ligne afin d’afficher la totalité
de son contenu. Elle est gérée par les contrôles possédant une propriété Caption et par TextBox,
mais pas par ListBox ni ComboBox. WordWrap accepte une valeur de type Boolean :
• True (par défaut, sauf pour les CommandButton). Le contrôle autorise les changements de
ligne.
• False. Il ne les autorise pas.
Lorsqu’un contrôle autorise un changement de ligne, celui-ci s’opère lorsque le contenu atteint la
limite d’affichage de ligne et si la hauteur autorise la création d’une ligne supplémentaire. Si tel
n’est pas le cas, aucun changement de ligne ne s’effectue. La figure 14-15 présente deux TextBox
dans lesquels un même texte a été saisi. La propriété WordWrap du premier est définie à True et
celle du second à False.
Info
Si la propriété MultiLine d’un TextBox est définie sur False, une seule ligne est autorisée dans la zone
d’édition ; WordWrap est donc sans effet.
Défilement
ScrollBars
Cette propriété détermine l’affichage d’une ou de plusieurs barres de défilement pour les feuilles,
les TextBox et les Frame. Les barres apparaissent lorsque les dimensions du contrôle ne permettent
pas d’afficher la totalité de son contenu. ScrollBars accepte l’une des constantes fmScrollBars :
• fmScrollBarsNone. Aucune barre de défilement ne s’affiche.
• fmScrollBarsHorizontal. Le contrôle possède une barre de défilement horizontale.
• fmScrollBarsVertical. Il possède une barre verticale.
• fmScrollBarsBoth. Il possède une barre horizontale et une verticale.
Info
Les ListBox ne gèrent pas la propriété ScrollBars. Ils affichent toujours une barre de défilement verti-
cale lorsque cela est nécessaire.
Un TextBox dont la propriété MultiLine est définie à False ne peut présenter de barre verticale,
puisque son contenu est toujours affiché sur une seule ligne. Un TextBox dont la propriété WordWrap
est définie à True ne peut posséder de barre horizontale, puisque, chaque fois que la limite d’affi-
chage liée aux dimensions du contrôle est atteinte, le contenu passe à la ligne suivante.
Une barre de défilement permet d’afficher une zone supérieure à la taille réelle d’une feuille ou
d’un contrôle MultiPage. Vous devez donc spécifier la taille totale de la zone affichable à l’aide
des barres de défilement (propriétés ScrollHeight et ScrollWidth). Elle doit évidemment être supé-
rieure à la taille réelle du contrôle (Height). ScrollHeight est, par conséquent, généralement définie
dans une procédure, relativement à la valeur de Height (par exemple, MonContrôle.ScrollHeight
= MonContrôle.Height * 1.5).
Pour plus de précisions sur l’utilisation des barres de défilement sur les feuilles et les contrôles
MultiPage, reportez-vous à l’Aide Visual Basic.
Conseil
Lorsque vous définissez à True les propriétés MultiLine et WordWrap d’un TextBox, affectez la valeur
fmScrollBarsVertical à sa propriété ScrollBars. Une barre de défilement sera ainsi ajoutée lorsque
les capacités d’affichage du contrôle seront dépassées.
Développer des interfaces utilisateur
372 Troisième partie
Conseil
Lorsque vous affectez une barre de défilement à un contrôle, assurez-vous que ce dernier dispose d’assez
d’espace sur la feuille pour l’afficher.
KeepScrollsVisible
Cette propriété détermine si les barres de défilement d’un contrôle sont ou non visibles lorsqu’elles
n’ont aucune utilité, c’est-à-dire lorsque la totalité du contenu du contrôle s’affiche. Elle accepte
l’une des constantes fmScrollBars :
• fmScrollBarsNone. Les barres de défilement ne sont affichées que lorsque les dimensions du
contrôle ne permettent pas d’en visualiser le contenu.
• fmScrollBarsHorizontal. La barre horizontale est toujours affichée.
• fmScrollBarsVertical. La barre verticale est toujours affichée.
• fmScrollBarsBoth. Les barres horizontale et verticale sont toujours affichées.
Delay
Cette propriété détermine la périodicité avec laquelle les événements SpinUp, SpinDown et Change
sont reconnus sur un contrôle SpinButton ou ScrollBar, lorsque l’utilisateur clique sur les flèches
ou dans la barre de défilement et maintient le bouton enfoncé. Elle accepte une valeur numérique
de type Long, qui représente la périodicité de déclenchement de l’événement en millisecondes.
Sa valeur par défaut est 50.
Pour vous déplacer à l’aide d’une barre de défilement ou modifier une valeur à l’aide d’un bouton
toupie, vous pouvez cliquer une fois sur le contrôle pour vous déplacer d’une unité ou maintenir
le bouton de la souris enfoncé. Dans ce cas, un premier événement se déclenche. Un court laps
de temps s’écoule, puis l’événement s’exécute en boucle à intervalles réguliers jusqu’à ce que
vous relâchiez le bouton de la souris. La propriété Delay correspond au temps séparant chaque
événement exécuté en série. Le laps de temps entre le premier événement et la série qui s’exécute
ensuite est égal à cinq fois la valeur de Delay ; il évite de déclencher toute une série d’événements
sur un seul clic de souris.
Conseil
Ne modifiez pas la valeur par défaut de la propriété Delay. Elle correspond au comportement habituel des
barres de défilement et des boutons toupies en environnement Windows.
Une valeur trop importante diminue l’efficacité du contrôle. Une valeur trop petite risque de déclencher une
série d’événements au moindre clic, alors que l’utilisateur ne souhaite en déclencher qu’un seul.
Exploiter les propriétés des contrôles
Chapitre 14
373
Max et Min
Les propriétés Max et Min d’un ScrollBar ou d’un SpinButton déterminent les valeurs maximale et
minimale que peut prendre le contrôle. Elles acceptent une valeur de type Integer.
Lorsque vous déplacez le curseur d’un ScrollBar ou cliquez sur l’une des flèches d’un SpinButton,
la propriété Value se déplace entre les valeurs Max et Min. Pour un ScrollBar, elle vaut Min lorsque
le curseur est tout en haut (barre verticale) ou tout à gauche (barre horizontale) et Max lorsque le
curseur est tout en bas ou à droite du contrôle. Pour un SpinButton, elle représente la valeur que
sélectionne l’utilisateur, se rapproche de Min lorsqu’il clique sur la flèche Haut ou Gauche et vers
Max lorsqu’il clique sur la flèche Bas ou Droite.
L’unité d’incrémentation de Value est déterminée par SmallChange, ainsi que par LargeChange dans
le cas d’un ScrollBar. C’est donc la conjugaison de ces trois propriétés qui détermine le nombre
de valeurs que peut prendre le contrôle (nombre de positions possibles pour le curseur d’un
ScrollBar). Ce nombre est égal à [(Max – Min) / SmallChange] + 1.
Si Min et Max sont respectivement définies à 0 et à 100 et SmallChange à 10, le contrôle peut prendre
onze valeurs (0, 10, …, 100). Chaque clic sur la flèche Bas ou Droite incrémentera la valeur
de 10, jusqu’à atteindre Max. Au-delà, les clics resteront sans effet. De la même façon, chaque
clic sur la flèche Haut ou Gauche ôtera 10 à la valeur, jusqu’à atteindre Min et les clics resteront
alors sans effet.
Info
Les valeurs par défaut des propriétés Min et Max d’un ScrollBar sont respectivement 0 et 32 767. La valeur
de SmallChange et LargeChange étant définie par défaut à 1, le contrôle ainsi déterminé accepte 32 768
positions.
Les valeurs par défaut des propriétés Min et Max d’un SpinButton sont respectivement 0 et 100. La valeur
de SmallChange étant définie par défaut à 1, le contrôle ainsi défini accepte 101 positions.
SmallChange
Cette propriété spécifie la valeur d’incrémentation de la propriété Value d’un ScrollBar ou d’un
SpinButton lors des événements SpinDown ou SpinUp. Elle accepte une valeur de type Integer.
Chaque fois que l’utilisateur clique sur la flèche Bas (contrôle vertical) ou Droite (contrôle horizon-
tal), Value est incrémentée de SmallChange, jusqu’à atteindre Max. Les clics restent alors sans effet.
Chaque fois que l’utilisateur clique sur la flèche Haut ou Gauche, Value est décrémentée de
SmallChange, jusqu’à atteindre Min. Les clics restent alors sans effet.
Conjuguée aux propriétés Min et Max du contrôle, SmallChange détermine le nombre de valeurs
possibles pour le contrôle, correspondant au nombre de positions du curseur sur la barre de défi-
lement dans le cas d’un ScrollBar.
Pour un exemple d’exploitation de ces propriétés, reportez-vous à la section consacrée à l’exploi-
tation des objets SpinButton décrite au chapitre suivant.
Développer des interfaces utilisateur
374 Troisième partie
LargeChange
Cette propriété spécifie la valeur d’incrémentation de la propriété Value d’un ScrollBar lorsque
l’utilisateur clique dans la barre de défilement, entre le curseur et l’une des flèches de défilement.
Elle accepte une valeur de type Integer (1 par défaut).
Chaque fois que l’utilisateur clique dans la barre de défilement, entre le curseur et la flèche Bas
(contrôle vertical) ou Droite (contrôle horizontal), Value est incrémentée de LargeChange, jusqu’à
atteindre Max. Les clics restent alors sans effet.
Quand l’utilisateur clique dans la barre de défilement, entre le curseur et la flèche Haut ou Gauche,
Value est décrémentée de LargeChange, jusqu’à atteindre Min. Les clics restent alors sans effet.
Dans l’environnement Windows, un clic dans une barre de défilement entraîne généralement un
déplacement supérieur à un clic sur la flèche (dans une feuille Excel par exemple, le déplacement
est respectivement d’un écran et d’une ligne).
Pour un exemple d’utilisation de la propriété LargeChange, voyez la section consacrée à l’exploi-
tation des objets ScrollBar, au chapitre suivant.
Divers
Accelerator
Cette propriété définit un raccourci clavier pour un contrôle. Elle accepte une valeur de type
String. Affectez-lui un des caractères formant le texte de sa propriété Caption.
La lettre du raccourci est soulignée dans le libellé du contrôle (seulement la première occurrence).
Sa casse ne sera considérée que si le libellé du contrôle contient à la fois la lettre majuscule et la
lettre minuscule.
Combinée à la touche Alt, la saisie de la touche de raccourci d’un contrôle lui passe le focus. Si
l’événement par défaut du contrôle est Click (pour un bouton de commande ou une case à cocher,
par exemple), alors il s’exécute.
La figure 14-16 présente une feuille dont tous les contrôles ont été affectés à un raccourci clavier.
Lorsqu’une touche de raccourci est affectée à un Label, elle entraîne le passage du focus au
contrôle suivant dans l’ordre de tabulation. Cette fonction est particulièrement intéressante pour
activer un TextBox.
Attention
Veillez à ne pas attribuer un même raccourci clavier à des contrôles différents sur une feuille. Sinon, cela
entraîne le passage du focus au premier suivant le contrôle actif, dans l’ordre de tabulation.
Exploiter les propriétés des contrôles
Chapitre 14
375
GroupName
Cette propriété permet d’associer des OptionButton, afin que l’utilisateur ne puisse valider que
l’un d’eux. Elle accepte une valeur de type String. Pour associer des boutons d’options, affectez
la même chaîne de caractères à leurs propriétés GroupName respectives.
Astuce
Notez qu’il existe deux moyens d’associer des boutons d’options sur une feuille : les placer sur un même
cadre (Frame) ou affecter une même valeur à leurs propriétés GroupName respectives. Cette seconde pos-
sibilité prend moins de place et offre plus de liberté puisque les boutons peuvent être placés n’importe où
sur la feuille. L’utilisation d’un cadre est cependant souvent v is ue lle m e nt plus efficace, surtout lorsque la
feuille propose plusieurs groupes.
Astuce
Pour définir à l’identique la propriété GroupName de plusieurs boutons d’options, sélectionnez-les sur la
feuille, ouvrez la fenêtre Propriétés (touche F4) et affectez la valeur de votre choix à GroupName. Tous les
contrôles sélectionnés sont affectés par cette modification.
HelpContextID
Cette propriété sert à spécifier une rubrique d’aide pour le contrôle. Elle accepte une valeur de
type Long correspondant à l’identificateur de contexte de l’une des rubriques du fichier d’aide. Cet
ouvrage n’aborde pas ce sujet.
Développer des interfaces utilisateur
376 Troisième partie
MouseIcon
Cette propriété spécifie une icône souris personnalisée pour le contrôle, c’est-à-dire l’apparence
que prend le pointeur lorsqu’il est placé au-dessus du contrôle. Pour que cette propriété ait un
effet, MousePointer doit être définie à fmMousePointerCustom. À partir de la fenêtre Propriétés :
1. Cliquez sur le bouton Parcourir de la propriété MouseIcon. La fenêtre Charger une image
s’affiche.
2. Sélectionnez un fichier de format valide (l’extension la plus courante est .ico), puis cliquez sur
Ouvrir.
Vous pouvez aussi écrire du code affectant une icône personnalisée à un contrôle en cours d’exé-
cution d’un programme. Faites pour cela appel à la fonction LoadPicture, selon la syntaxe suivante :
Contrôle.MouseIcon = LoadPicture(NomIcône)
Attention
Pour affecter un curseur personnalisé à un contrôle, vous devez également affecter la valeur fmMouse-
PointerCustom à sa propriété MousePointer – que le curseur soit affecté au contrôle lors de la phase de
conception de la feuille ou lors de l’exécution du code à l’aide de la fonction LoadPicture.
MousePointer
Cette propriété détermine l’apparence du pointeur de souris du contrôle. Elle accepte pour valeur
l’une des dix-sept constantes fmMousePointer. Les seize premières correspondent à des pointeurs
prédéfinis et la dix-septième, fmMousePointerCustom, permet de personnaliser l’apparence (voir
section précédente).
Exploiter les propriétés des contrôles
Chapitre 14
377
Pour visualiser les différents pointeurs disponibles, placez sur une feuille un ComboBox et un
CommandButton puis définissez leurs propriétés comme indiqué dans le tableau suivant :
Propriété Valeur
Feuille
Name fmTestPointeur
Contrôle ComboBox
Name cboConstantes
Locked True
Contrôle CommandButton
Name cmdQuitter
Value Quitter
Private Sub cboConstantes_Click()
cmdQuitter.MousePointer = cboConstantes.ListIndex
End Sub
Private Sub cmdQuitter_Click()
fmTestPointeur.Hide
End Sub
Sélectionnez ensuite la feuille dans Visual Basic Editor, puis cliquez sur le bouton Exécuter de la
barre d’outils Standard. La feuille s’affiche. Sélectionnez une à une les différentes options de la
liste déroulante et placez le pointeur sur le bouton pour chaque sélection. Cliquez sur le bouton
Quitter pour fermer le programme et retourner à Visual Basic Editor.
Info
Lorsque vous modifiez la propriété MousePointer d’un objet UserForm (feuille), le pointeur de souris déter-
miné affecte toutes les feuilles, quel que soit le contrôle au-dessus duquel il se trouve. Pour le vérifier,
remplacez l’instruction suivante :
cmdQuitter.MousePointer = cboConstantes.ListIndex
par :
fmTestPointeur.MousePointer = cboConstantes.ListIndex
Développer des interfaces utilisateur
378 Troisième partie
TabIndex
Cette propriété détermine la position du contrôle dans l’ordre de tabulation de la feuille. Elle
accepte une valeur de type Integer, comprise entre 0 et le nombre de contrôles de la feuille
moins 1.
Info
Pour un rappel des notions de focus et d’ordre de tabulation, reportez-vous à la section décrivant la pro-
priété AutoTab, plus haut dans ce chapitre.
Lorsque l’utilisateur tape sur la touche Tab, le focus passe au contrôle dont la propriété TabIndex
vaut celle du contrôle actif plus 1. S’il utilise la combinaison Maj+Tab, le focus passe au contrôle
dont la propriété TabIndex vaut celle du contrôle actif moins 1.
Si la propriété Enabled du contrôle suivant est définie à False, il est ignoré et le focus passe au
contrôle d’après, dans l’ordre de tabulation de la feuille. Si vous souhaitez qu’un contrôle soit
ignoré dans l’ordre de tabulation tout en restant accessible à l’utilisateur, définissez sa propriété
TabStop à False.
Pour définir l’ordre de tabulation d’une feuille en phase de conception, il est plus simple d’utiliser
la boîte de dialogue Ordre de tabulation que de définir une à une les TabIndex des contrôles :
1. Cliquez-droit sur la feuille (pas sur un contrôle) et choisissez la commande Ordre de tabulation
(voir figure 14-19). Les contrôles de la feuille sont répertoriés par leur nom (Name) et classés
selon leur position dans l’ordre de tabulation (celui dont la propriété TabIndex est égale à 0 se
trouve tout en haut de la liste).
2. Sélectionnez un contrôle et cliquez sur le bouton Vers le haut ou Vers le bas pour le déplacer
dans l’ordre de tabulation. À chaque mouvement, sa propriété TabIndex et celle du contrôle
dont il prend la place sont interverties.
Exploiter les propriétés des contrôles
Chapitre 14
379
3. Vous pouvez déplacer simultanément des contrôles, en conservant leurs positions relatives.
Pour sélectionner des contrôles contigus (resp. non contigus), utilisez la touche Maj (resp. Ctrl).
Figure 14-20 – Déplacez simultanément les contrôles dont vous souhaitez modifier la position
dans l’ordre de tabulation, tout en conservant leurs positions relatives.
TabStop
Cette propriété détermine si un contrôle peut ou non recevoir le focus lorsque l’utilisateur tape
sur la touche Tab ou sur la combinaison Maj+Tab. Elle accepte une valeur de type Boolean :
• True (par défaut). Si sa position dans l’ordre de tabulation le justifie, le contrôle reçoit le focus
lorsque la touche Tab ou la combinaison Maj+Tab est activée.
• False. Le focus ne peut être passé au contrôle par la touche Tab. Bien qu’il conserve sa propriété
TabIndex, il est ignoré s’il est le suivant (touche Tab seule) ou le précédent (Maj+Tab) dans
l’ordre de tabulation, et le focus est passé à celui d’après.
Tag
Cette propriété stocke des informations supplémentaires sur le contrôle sous la forme d’une chaîne
de caractères. Il peut s’agir d’une description du contrôle, affichée à l’utilisateur si nécessaire.
Développer des interfaces utilisateur
380 Troisième partie
Emplacement
Height et Width
Ces propriétés, de type Single, déterminent respectivement la hauteur et la largeur en points
d’un contrôle.
Vous n’avez a priori pas à vous en préoccuper, puisqu’elles sont automatiquement mises à jour
lorsque vous redimensionnez le contrôle dans Visual Basic Editor. Préférez donc les méthodes
de dimensionnement présentées au chapitre précédent.
Left et Top
Ces propriétés, de type Single, déterminent la distance en points du contrôle, respectivement par
rapport au bord gauche et au bord supérieur de l’objet qui le contient.
Vous n’avez a priori pas à vous en préoccuper, puisqu’elles sont automatiquement mises à jour
lorsque vous déplacez le contrôle dans Visual Basic Editor. Préférez donc les méthodes de mise
en forme présentées au chapitre précédent.
Dans le cas d’une feuille, les propriétés Left et Top représentent la distance en points de la feuille
par rapport aux bords gauche et supérieur de l’écran lors de son affichage. Elles ne sont considérées
que si la propriété StartUpPosition de la feuille est définie à 0 (manuel).
StartUpPosition
Cette propriété détermine la position de la feuille sur l’écran. Elle accepte l’une des valeurs
suivantes :
• 0 – Manual. La position de la feuille sur l’écran est déterminée par ses propriétés Left et Top.
• 1 – CenterOwner (par défaut). La feuille est centrée sur la fenêtre de l’application hôte.
• 2 – CenterScreen. La feuille est centrée sur l’écran, quelles que soient la position et la taille
de la fenêtre de l’application hôte.
• 3 – Windows Default. La feuille s’affiche dans l’angle supérieur gauche de l’écran. Utilisez
cette valeur lorsque vous souhaitez que la feuille affichée masque le moins possible le docu-
ment actif.
Exploiter les propriétés des contrôles
Chapitre 14
381
Image
Picture
Cette propriété affecte une image à un contrôle ou à une feuille :
1. Affichez la fenêtre Propriétés de l’objet et cliquez sur le bouton Parcourir (…) de Picture.
La boîte de dialogue Charger une image s’affiche (voir figure 14-23).
Figure 14-23 – Sélectionnez le fichier image que vous souhaitez affecter au contrôle.
2. Sélectionnez un fichier de format valide qui sera utilisé comme image pour le contrôle ou la
feuille (.bmp et .ico sont des formats valides), puis cliquez sur Ouvrir.
Vous pouvez aussi écrire du code affectant une image à un objet en cours d’exécution d’un pro-
gramme, grâce à la fonction LoadPicture, selon la syntaxe suivante :
Objet.Picture = LoadPicture(NomImage)
Figure 14-24 – Vous pouvez donner un peu de fantaisie à vos feuilles en leur affectant des images.
Exploiter les propriétés des contrôles
Chapitre 14
383
Pour supprimer une image d’un contrôle, sélectionnez la valeur de Picture dans la fenêtre
Propriétés et appuyez sur la touche Suppr.
PictureAlignment
Cette propriété détermine l’emplacement d’une image (propriété Picture) sur un contrôle ou sur
une feuille. Elle accepte pour valeur l’une des constantes fmPictureAlignment :
• fmPictureAlignmentTopLeft. L’image est placée dans l’angle supérieur gauche de l’objet.
• fmPictureAlignmentTopRight. L’image est placée dans l’angle supérieur droit de l’objet.
• fmPictureAlignmentCenter (par défaut). L’image est centrée sur l’objet.
• fmPictureAlignmentBottomLeft. L’image est placée dans l’angle inférieur gauche de l’objet.
• fmPictureAlignmentBottomRight. L’image est placée dans l’angle inférieur droit de l’objet.
Pour les CommandButton, PictureAlignment est remplacée par PicturePosition. Utilisez cette
propriété pour affecter une image à un bouton de commande sans en masquer le libellé. Par
exemple, une image a été affectée à la propriété Picture des trois CommandButton de la figure 14-25.
PicturePosition a été définie sur fmPicturePositionLeftCenter. Notez le contrôle (et non la pro-
priété) Picture représentant une imprimante.
Astuce
Réalisez une capture d’écran d’une fenêtre dont vous souhaitez exploiter les icônes. Détourez ces der-
nières dans un logiciel de dessin tel que Paint Shop Pro et enregistrez-les au format BMP. Vous pourrez
ensuite les exploiter dans vos feuilles VBA comme contrôles Picture ou comme propriétés Picture de
CommandButton.
Développer des interfaces utilisateur
384 Troisième partie
PicturePosition
Cette propriété détermine la position de l’image d’un CommandButton par rapport à sa légende.
Elle accepte pour valeur l’une des treize constantes fmPicturePosition. Pour plus d’informations,
reportez-vous à l’Aide Visual Basic.
PictureSizeMode
Cette propriété détermine de quelle façon l’image d’un contrôle ou d’une feuille s’affiche si sa
taille diffère de celle de l’objet conteneur. Elle n’est pas gérée par les CommandButton. Elle accepte
pour valeur l’une des constantes fmPictureSizeMode :
• fmPictureSizeModeClip (par défaut). Si la taille de l’image est supérieure à celle du contrôle,
seule la partie tenant dans le contrôle s’affiche. La partie rognée variera en fonction de
PictureAlignment.
• fmPictureSizeModeStretch. L’image est redimensionnée à la même taille que l’objet conteneur.
Si le rapport homothétique n’est pas équilibré, l’image sera déformée.
• fmPictureSizeModeZoom. L’image est redimensionnée proportionnellement. Si le rapport homo-
thétique n’est pas équilibré, l’image occupera toute la largeur de l’objet conteneur, mais pas
toute la hauteur, ou inversement.
PictureTiling
Cette propriété détermine si une image est ou non affichée en mosaïque sur une feuille ou un
contrôle. Elle accepte une valeur de type Boolean :
• True. Si l’image est plus petite que l’objet conteneur, elle s’affiche en mosaïque sur la page
(voir figure 14-26). Pour que l’affichage en mosaïque s’effectue correctement, la propriété
PictureSizeMode doit être définie à fmPictureSizeModeClip.
• False (par défaut). L’image n’est pas affichée en mosaïque.
Info
Une image affichée en mosaïque sur une feuille ou un contrôle risque d’être rognée sur le bord supérieur
ou inférieur de l’objet, ainsi que sur son bord gauche ou droit. Il est en effet peu probable que la hauteur et
la largeur de l’objet conteneur soient des multiples de celles de l’image. Les bords rognés dépendront de
l’alignement de l’image sur l’objet (PictureAlignment).
Police
Font
Cette propriété détermine la police de caractères affectée à l’affichage du contenu d’un contrôle
(Tahoma Regular corps 8, par défaut). Pour la modifier, cliquez sur le bouton … dans le volet
droit de la fenêtre Propriétés du contrôle. Dans la boîte de dialogue qui s’affiche, déterminez la
police de caractères et les attributs voulus, puis cliquez sur OK.
15
Maîtriser le comportement
des contrôles
Ce chapitre vous propose de découvrir comment rendre les interfaces utilisateur vraiment fonc-
tionnelles en leur ajoutant de l’interactivité grâce aux procédures événementielles. Il vous présente
également les techniques les plus courantes pour tirer parti des propriétés de chaque contrôle.
L’instruction de déclaration est toujours précédée de Private, car une procédure événementielle est
par définition privée. Elle ne s’exécute que lorsque l’événement est repéré et ne peut être appelée
par une instruction située dans une procédure du projet.
Contrôle est le nom (propriété Name) du contrôle auquel est attachée la procédure. Evénement déclen-
chera la procédure lorsqu’il affectera le contrôle ; il peut s’agir d’un clic de souris, d’une frappe
de la touche Entrée ou encore d’une modification de la valeur du contrôle. Le nom du contrôle et
celui de l’événement sont toujours séparés par un trait de soulignement.
Info
Dans le cas de procédures événementielles affectées à des feuilles, le nom de l’objet n’apparaît pas dans
l’instruction de déclaration. Le mot-clé UserForm est dans ce cas employé pour identifier la feuille :
Private Sub UserForm_Evénement()
Vous pouvez écrire une procédure événementielle directement dans la fenêtre de Code de la feuille,
en adoptant l’une des méthodes présentées plus loin dans ce chapitre. Cliquez-droit n’importe où
sur la feuille et choisissez la commande Code.
Les instructions de déclaration peuvent cependant être ajoutées automatiquement à partir de la
feuille. Pour affecter une procédure événementielle à un contrôle, à partir de l’objet conteneur :
1. Double-cliquez sur le contrôle voulu, ou cliquez-droit et choisissez la commande Code (voir
figure 15-1), ou sélectionnez le contrôle puis choisissez la commande Code du menu Affichage.
2. La fenêtre Code de la feuille s’ouvre. Les instructions de déclaration par défaut de la procédure
événementielle du contrôle sont automatiquement insérées et le curseur est placé entre elles
(voir figure 15-2).
• L’événement affecté à la procédure est l’événement par défaut du contrôle. Il varie d’un contrôle
à l’autre : Click (clic de souris) pour un CommandButton, Change (modification de la valeur) pour
un TextBox...
3. Si l’événement n’est pas celui que vous voulez, modifiez-le au clavier, ou déroulez la liste
Procédure pour faire votre choix (voir figure 15-3) parmi tous ceux susceptibles d’affecter le
contrôle et supprimez les déclarations précédentes.
4. Saisissez le code de la procédure entre les instructions de déclaration.
Info
Si la procédure événementielle existe déjà, le curseur est placé sous son instruction de déclaration.
Pour réaliser l’exemple suivant, créez une feuille et placez-y un Label , un TextBox , quatre
OptionButton et trois CommandButton, en définissant leurs propriétés selon le tableau suivant.
Propriété Valeur
Feuille
Name fmTestEvénements
Caption Test des procédures événementielles
Contrôle Label
Name lbTexte
Value Entrez le texte de votre choix
Contrôle TextBox
Name txtTexte
Value
Contrôles OptionButton
Name De optOption1 à optOption4
Value True pour l’un des boutons ; False pour les autres
Caption De Bouton d’option 1 à Bouton d’option 4
Contrôles CommandButton
Name Respectivement cmdBouton, cmdTexte et cmdQuitter
Caption Respectivement Bouton actif, Zone de texte et Quitter
Enfin, affectez les procédures événementielles suivantes au TextBox et aux trois CommandButton.
Maîtriser le comportement des contrôles
Chapitre 15
391
Private Sub txtTexte_AfterUpdate()
MsgBox "Vous avez modifié la valeur de la zone de texte.", _
vbOKOnly + vbInformation, "Evénement AfterUpdate() détecté"
End Sub
Private Sub cmdBouton_Click()
Dim BoutonActif As String
If optOption1.Value=True Then
BoutonActif = optOption1.Caption
ElseIf optOption2.Value=True Then
BoutonActif = optOption2.Caption
ElseIf optOption3.Value=True Then
BoutonActif = optOption3.Caption
Else
BoutonActif = optOption4.Caption
End If
MsgBox "Le bouton d'option sélectionné est le bouton libellé " _
& BoutonActif, vbOKOnly + vbInformation, "Evénement Click() détecté"
End Sub
Private Sub cmdTexte_Click()
MsgBox "La valeur de la zone de texte est : " & txtTexte.Value, _
vbOKOnly + vbInformation, "Evénement Click() détecté"
End Sub
Private Sub cmdQuitter_Click()
fmTestEvénements.Hide
End Sub
Sélectionnez la feuille dans la fenêtre UserForm et cliquez sur le bouton Exécuter de la barre
d’outils Standard. La feuille s’affiche à l’écran. Testez son comportement. Lorsque les événements
affectés à une procédure événementielle sont détectés, cette dernière s’exécute :
• La modification de la valeur de la zone de texte est interprétée comme l’événement AfterUpdate
affectant txtTexte lors du passage du focus à un autre contrôle. La procédure correspondante
est exécutée et la boîte de dialogue de la figure 15-5 s’affiche.
• Un clic sur Bouton actif est détecté comme l’événement Click affectant cmdBouton. La procédure
correspondante est exécutée et la boîte de dialogue de la figure 15-6 s’affiche.
• Un clic sur Zone de texte est détecté comme l’événement Click affectant cmdTexte. La procédure
correspondante est exécutée et la boîte de dialogue de la figure 15-7 s’affiche.
• Un clic sur Quitter est détecté comme l’événement Click affectant cmdQuitter. La procédure
correspondante est exécutée et la fenêtre se ferme.
Développer des interfaces utilisateur
392 Troisième partie
Les événements
Les événements sont nombreux et varient d’un contrôle à l’autre. Ceux qu’un contrôle sait gérer
sont intimement liés à sa nature, c’est-à-dire à ses propriétés. Par exemple, les événements Change,
AfterUpdate et BeforeUpdate sont gérés uniquement par les contrôles possédant une propriété
Value (les TextBox, par exemple, mais pas les CommandButton), puisqu’ils se déclenchent lors de la
modification de cette propriété.
Astuce
Pour accéder à la liste des événements gérés, sélectionnez le contrôle sur une feuille et tapez sur F1 pour
ouvrir la rubrique d’aide qui lui est associée.
Cette section présente les événements gérés par les contrôles VBA. Certains, tels que Click, Change
ou Initialize, sont essentiels. Ils apparaissent en gras dans la liste. Il en est d’autres que vous
n’utiliserez que très rarement, voire jamais.
• AfterUpdate est détecté lorsque la valeur du contrôle est modifiée, au moment du passage du
focus à un autre contrôle. Cet événement survient après BeforeUpdate.
• BeforeDragOver est détecté lors d’un glisser-déplacer.
• BeforeDropOrPaste est détecté lorsque des données sont déposées ou collées sur un objet.
L’événement survient avant que l’action ne soit validée.
• BeforeUpdate est détecté lorsque la valeur du contrôle est modifiée, au moment du passage
du focus à un autre contrôle. Cet événement survient avant que la modification des données
ne soit validée – et donc avant AfterUpdate. Cela permet de refuser la mise à jour effectuée.
BeforeUpdate répond à la syntaxe suivante :
Pour refuser la mise à jour, placez l’instruction Annulation = True dans la procédure. L’utilisateur
ne pourra alors pas passer le focus à un autre contrôle tant qu’une valeur valide n’aura pas été
affectée au contrôle.
Dans l’exemple suivant, si l’utilisateur n’entre pas un nombre compris entre 50 et 250 dans la
zone de texte txtTaille, un message l’avertit que la valeur n’est pas valide et le focus ne peut
être passé à un autre contrôle tant que ce n’est pas corrigé.
1: Private Sub txtValeur_BeforeUpdate(ByVal Annulation _
As MSForms.ReturnBoolean)
2: If IsNumeric(txtValeur.Value)=False Then
3: MsgBox "Vous devez indiquer une valeur numérique"
4: Annulation = True
5: Else
6: If Not (txtValeur.Value>=50 And txtValeur.Value<=250) Then
7: MsgBox "Valeur non valide"
8: Annulation = True
9: End If
10: End If
11: End Sub
Développer des interfaces utilisateur
394 Troisième partie
L’instruction If…End If principale (des lignes 2 à 10) vérifie si la valeur entrée est un nombre.
Si tel n’est pas le cas (ligne 2), un message s’affiche (ligne 3) et la modification est refusée
(ligne 4), interdisant à l’utilisateur de passer le focus à un autre contrôle. Si la valeur entrée
est un nombre (ligne 5), une instruction If…End If imbriquée (des lignes 6 à 9) vérifie qu’il est
compris entre 50 et 250. Si tel n’est pas le cas, un message s’affiche (ligne 7) et la modification
est refusée (ligne 8)
• Change est détecté lors de la modification de la valeur (Value) d’un contrôle. La modification
provient soit de l’utilisateur, soit d’une instruction du code. Contrairement à AfterUpdate et
BeforeUpdate qui sont déclenchés lors du passage du focus à un autre objet, Change est détecté
à chaque modification de la valeur. Ainsi, si vous affectez une procédure d’événement Change
à un TextBox, elle s’exécutera chaque fois que l’utilisateur entrera ou supprimera un caractère
dans la zone de texte (s’il saisit le mot « Bonjour » dans la zone de texte, la procédure se
déclenchera sept fois).
Il est fréquent d’utiliser une zone de texte pour afficher l’élément sélectionné par l’utilisateur
dans une liste. La procédure événementielle suivante met à jour la zone de texte txtSélListe
chaque fois que l’utilisateur modifie la sélection dans la liste ZoneDeListe :
Private Sub ZoneDeListe_Change()
txtSélListe.Value = ZoneDeListe.Value
End Sub
• Click est détecté lorsque l’utilisateur clique sur un contrôle, mais aussi quand l’équivalent
clavier d’un clic de souris est tapé. C’est le cas si l’utilisateur frappe la touche Entrée alors
qu’un bouton de commande a le focus, ou la barre d’espace alors qu’une case à cocher a le
focus. Lorsque vous cliquez sur un contrôle, trois événements sont successivement détectés :
MouseDown, MouseUp, puis Click.
• dblClick est détecté lorsque l’utilisateur double-clique sur un contrôle. Lors d’un double-clic,
quatre événements sont donc successivement détectés : MouseDown, MouseUp, Click, puis dblClick.
• DropButtonClick est détecté chaque fois que l’utilisateur déroule ou ferme une liste déroulante
modifiable.
• Enter est détecté juste avant qu’un contrôle reçoive le focus. Il est toujours lié à un événement
Exit affectant le contrôle qui avait le focus précédemment.
• Exit est détecté juste avant qu’un contrôle ne perde le focus. Il répond à la syntaxe suivante :
Private Sub Contrôle_Exit(ByVal Annulation As MSForms.ReturnBoolean)
Pour annuler le passage du focus, affectez la valeur True à l’argument Annulation dans une
instruction de la procédure événementielle (voir l’exemple donné pour BeforeUpdate).
• Initialize est détecté lorsqu’une feuille est chargée. La procédure affectée à cet événement
s’exécute avant l’affichage de la feuille et s’utilise selon la syntaxe suivante :
Private Sub UserForm_Initialize()
Instructions
End Sub
Maîtriser le comportement des contrôles
Chapitre 15
395
Notez que, dans le cas de la procédure Initialize d’une feuille, le nom de cette dernière n’est
pas utilisé pour spécifier l’objet ; on utilise toujours le mot-clé UserForm.
C’est une procédure absolument essentielle de la programmation VBA. Elle permet en effet
d’effectuer des réglages de la feuille avant son affichage. Vous l’utiliserez, par exemple, pour
affecter une liste d’éléments à un ListBox ou un ComboBox de la feuille. Reportez-vous à la
section « ComboBox », plus loin dans ce chapitre.
Attention
Lorsque vous utilisez la méthode Hide pour masquer une feuille précédemment affichée à l’aide de Show,
les ressources mémoire qu’elle occupe ne sont pas libérées. Si, par la suite, vous affichez de nouveau la
feuille, l’événement Initialize ne sera donc pas reconnu et ses différents contrôles auront les mêmes
valeurs que lorsqu’elle a été masquée. Pour libérer les ressources mémoire d’une feuille UserForm, vous
devez lui appliquer la méthode Unload, selon la syntaxe suivante :
Unload NomFeuille
La méthode Load charge une feuille en déclenchant la procédure événementielle Initialize, sans pour
autant l’afficher. Notez que, pour manipuler une feuille par programmation, il faut qu’elle soit chargée (à
l’aide de Show ou de Load).
• KeyDown est détecté lorsqu’une touche du clavier est enfoncée. Il répond à la syntaxe suivante :
Private Sub Contrôle_KeyDown(ByVal CodeTouche As MSForms.ReturnInteger,
ByVal EtatMaj As Integer)
CodeTouche renvoie le code de la touche frappée et EtatMaj renvoie l’état des touches Maj, Ctrl
et Alt (0 si aucune n’est enfoncée, 1 si Maj est enfoncée, 2 si c’est Ctrl, 4 si c’est Alt, ces valeurs
s’additionnant si plusieurs de ces touches sont enfoncées).
Lorsque l’utilisateur enfonce une touche, KeyDown et KeyPress sont successivement détectés. S’il
maintient la touche enfoncée, ces événements sont à nouveau détectés en série, le processus
reflétant la périodicité d’insertion du caractère.
• KeyPress est détecté lorsque l’utilisateur appuie sur une touche ANSI. Il intervient immé-
diatement après KeyDown. Si la touche reste enfoncée, KeyPress est détecté en série, à chaque
insertion d’un caractère. Il répond à la syntaxe suivante :
Private Sub Contrôle_Keypress(ByVal codeANSI As MSForms.ReturnInteger)
• KeyUp est détecté lorsqu’une touche est relâchée. Il répond à la syntaxe suivante :
Private Sub Contrôle_KeyUp(ByVal CodeTouche As MSForms.ReturnInteger,
ByVal EtatMaj As Integer)
Les valeurs affectées aux variables CodeTouche et EtatMaj sont les mêmes que pour KeyDown.
Pour visualiser le déroulement des événements KeyDown, KeyUp et KeyPress, placez un TextBox sur
une feuille, définissez sa propriété Name à txtTexte, puis placez le code suivant dans la section
Déclarations de la fenêtre Code de la feuille :
Développer des interfaces utilisateur
396 Troisième partie
Testez différentes combinaisons clavier dans la zone de texte du contrôle, puis cliquez sur la
case de fermeture de la feuille. Affichez la fenêtre Exécution (Ctrl+G). Le détail des événements
détectés y est inscrit figure 15-8).
La première procédure est déclenchée lorsque l’événement KeyDown est détecté sur txtTexte.
Une instruction Select Case…End Select teste la valeur de EtatMaj (lignes 3 à 20) et affecte une
chaîne de caractères à EtatTouches en fonction du résultat. L’instruction de la ligne 21 inscrit
dans la fenêtre Exécution de la feuille les informations ainsi récoltées.
La deuxième procédure est déclenchée lorsque l’événement KeyUp est détecté sur txtTexte. Une
chaîne est alors insérée dans la fenêtre Exécution de la feuille (ligne 24).
La troisième procédure est déclenchée lorsque l’événement KeyPress est détecté sur txtTexte.
L’instruction de la ligne 27 insère dans la fenêtre Exécution une chaîne suivie de la valeur de
codeANSI et du caractère correspondant.
Maîtriser le comportement des contrôles
Chapitre 15
397
• MouseDown est détecté lorsque l’utilisateur enfonce un bouton de souris. Il répond à la syntaxe
suivante :
Private Sub Contrôle_MouseDown(ByVal Bouton As fmButton,
ByVal EtatMaj As fmShiftState, ByVal X As Single, ByVal Y As Single)
Bouton indique quel bouton a été enfoncé : 1 pour le gauche, 2 pour le droit, 4 pour celui du
centre, ces valeurs s’additionnant quand plusieurs boutons sont utilisés simultanément. EtatMaj
reflète l’état des touches Maj, Ctrl et Alt ; les valeurs sont les mêmes que pour KeyDown et KeyUp.
X et Y indiquent respectivement les distances horizontale et verticale du curseur par rapport à
l’angle supérieur gauche de la feuille, au moment du clic de souris.
• MouseMove est détecté lorsque l’utilisateur déplace la souris. La syntaxe est la même que pour
MouseDown.
• MouseUp est détecté lorsque l’utilisateur relâche un bouton de souris. La syntaxe est la même
que pour MouseDown.
• SpinDown est détecté lorsqu’un clic est effectué sur le bouton inférieur ou gauche d’un
SpinButton. La propriété Value du contrôle est alors décrémentée de la valeur de SmallChange,
sans dépasser Min.
• SpinUp est détecté quand on clique sur le bouton supérieur ou droit d’un SpinButton. La pro-
priété Value du contrôle est alors incrémentée de la valeur de SmallChange, sans dépasser Max.
Développer des interfaces utilisateur
398 Troisième partie
Label
Le texte d’un Label n’est pas modifiable par l’utilisateur. Cependant, il est parfois utile de le
changer afin de créer une interface utilisateur dynamique. Il suffit pour cela de placer des ins-
tructions redéfinissant la valeur Caption du contrôle lorsqu’un événement spécifique survient.
Vous pouvez ainsi placer un seul contrôle sur une feuille, destiné à remplir une fonction variable
selon les informations entrées par l’utilisateur ; c’est alors le Label l’identifiant qui indiquera sa
fonction à l’utilisateur.
Dans l’exemple suivant, un Label est affecté à une zone de texte, destinée à recevoir le nom d’un
nouveau membre. Deux boutons d’option, respectivement libellés «Masculin» et «Féminin»,
servent à spécifier le sexe du membre, le premier étant actif par défaut. Des procédures événemen-
tielles sont attachées à chacun des contrôles, afin que l’activation de l’un ou l’autre des boutons
d’option modifie la propriété Caption du Label.
Pour réaliser cet exemple, créez une nouvelle feuille et placez-y un Frame contenant deux
OptionButton, deux TextBox associés à un Label, et deux CommandButton. Définissez ainsi leurs
propriétés :
Propriété Valeur
Feuille
Name fmLabel
Caption Modification d’un contrôle
Label
Contrôle Frame
Name frSexe
Caption Sexe du nouveau membre
Contrôle OptionButton
Name optMasculin
Caption Masculin
Value True
Contrôle OptionButton
Name optFeminin
Caption Féminin
Value False
Contrôle Label
Name lbPrenom
Caption Prénom
Contrôle TextBox
Maîtriser le comportement des contrôles
Chapitre 15
399
Propriété Valeur
Name txtPrenom
Value
Contrôle Label
Name lbNom
Caption Nom
Contrôle TextBox
Name txtNom
Value
Contrôle CommandButton
Name cmdOK
Caption OK
Contrôle CommandButton
Name cmdAnnuler
Caption Annuler
Placez ensuite le code suivant dans la section Déclarations de la fenêtre Code de la feuille :
Sub optFeminin_Click()
lbNom.Caption = "Nom de jeune fille"
End Sub
Sub optMasculin_Click()
lbNom.Caption = "Nom"
End Sub
Sub cmdOK_Click()
fmLabel.Hide
End Sub
Sélectionnez ensuite la feuille, puis cliquez sur le bouton Exécuter de la barre d’outils Standard.
Lorsque vous cliquez sur l’un des boutons d’option, le libellé de lbNom varie en fonction de l’option
sélectionnée (voir figure 15-9).
Attention
Lorsque vous écrivez du code modifiant la valeur Caption d’un Label, veillez à ce que la taille du contrôle
permette l’affichage complet du nouveau libellé.
Développer des interfaces utilisateur
400 Troisième partie
Figure 15-9 – Faites varier le libellé d’un contrôle Label de façon à refléter l’information attendue.
Contrôle TextBox
Lorsque vous utilisez un TextBox destiné à recevoir une information bien spécifique, vérifiez que
l’utilisateur entre une valeur valide. Par exemple, si vous attendez une valeur représentant une
somme à payer, assurez-vous que l’information entrée correspond bien à un nombre et qu’elle
s’inscrit bien entre les limites éventuellement définies.
Pour vérifier la valeur d’un TextBox au moment où l’utilisateur la saisit, attachez du code à son
événement Change. Il est parfois aussi nécessaire de vérifier qu’une valeur a bien été entrée au
moment de la validation des informations entrées par l’utilisateur. Utilisez les fonctions Visual
Basic contrôlant les types de données.
Rappel
Pour un rappel des fonctions contrôlant les types de données, reportez-vous au tableau 6-3.
Astuce
Pour vérifier qu’une valeur est une chaîne de caractères, utilisez la fonction IsNumeric qui doit alors ren-
voyer la valeur False.
Pour réaliser l’exemple suivant, créez une feuille présentant un Label, un TextBox et un CommandButton
(voir figure 15-10) dotés des propriétés suivantes :
Maîtriser le comportement des contrôles
Chapitre 15
401
Propriété Valeur
Feuille
Name fmMaFeuille
Caption Vérification des données
Contrôle Label
Name lbValeur
Caption Entrez la somme à traiter :
Contrôle TextBox
Name txtValeur
Value
Contrôle CommandButton
Name cmdOK
Caption OK
Private Sub cmdOK_Click()
If txtValeur.Value="" Then
MsgBox txtValeur.Value & "Vous devez entrer une valeur dans la zone de texte.", _
vbExclamation, "Valeur requise"
Else
fmMaFeuille.Hide
End If
End Sub
Développer des interfaces utilisateur
402 Troisième partie
La première procédure utilise la fonction IsNumeric dans une instruction conditionnelle If…End If
pour s’assurer que la valeur entrée dans la zone de texte est une valeur numérique ou une chaîne
vide. Si tel n’est pas le cas, une boîte de dialogue s’affiche à l’attention de l’utilisateur (voir
figure 15-11) et la propriété Value du contrôle reçoit une chaîne vide.
Figure 15-11 – Une valeur non valide a été saisie dans la zone de texte.
La procédure cmdOK_Click vérifie qu’une valeur a bien été entrée dans la zone de texte. Si tel n’est
pas le cas, une boîte de dialogue s’affiche à l’attention de l’utilisateur (voir figure 15-12). Si, au
contraire, la zone de texte contient une valeur, alors la méthode Hide est appliquée à la feuille
afin de la masquer.
Figure 15-12 – Une valeur doit être saisie dans la zone de texte.
Info
Notez que la procédure Cmd_Click ne vérifie pas que la valeur de la zone de texte est valide (de type
numérique), mais uniquement qu’elle est différente d’une chaîne vide. En effet, c’est la procédure txtVa-
leur_Change qui s’en charge.
ComboBox
Les ComboBox sont très fréquents dans les interfaces utilisateur de la plupart des logiciels. Ils
présentent en effet l’avantage d’afficher un grand nombre d’options en n’occupant qu’un espace
très limité sur la feuille.
Maîtriser le comportement des contrôles
Chapitre 15
403
Par défaut, un ComboBox se comporte à la manière d’un TextBox, c’est-à-dire que l’utilisateur est
autorisé à saisir une valeur ne figurant pas parmi les options de la liste déroulante. Vous pouvez
cependant déterminer un comportement analogue à celui d’un ListBox, c’est-à-dire interdire la
saisie de nouvelles valeurs. Définissez pour cela la propriété Style du contrôle à fmStyleDropDown-
List (voir chapitre précédent).
La méthode AddItem
La liste affectée à un ComboBox est généralement déterminée dans le code du programme, à l’aide
de la méthode AddItem, selon la syntaxe suivante :
Contrôle.AddItem(ElementAjoutéALaListe, Index)
ElementAjoutéALaListe est une chaîne de caractères et Index est la position de l’élément dans la
liste (0 pour le premier élément). Ce dernier argument est généralement omis ; l’élément ajouté
est alors placé en dernière position.
Info
Lorsque Index est omis, ElementAjoutéALaListe peut être placé directement derrière AddItem, en igno-
rant les parenthèses.
Les instructions définissant les éléments de la liste d’un ComboBox sont généralement placées dans
une procédure événementielle attachée à l’événement Initialize de la feuille. La liste est ainsi
mise à jour au moment de l’affichage de cette dernière.
Pour réaliser l’exemple suivant, placez un Label, un ComboBox et un CommandButton sur une feuille,
dotés des propriétés suivantes :
Propriété Valeur
Feuille
Name fmComboBox
Caption Utilisation d’un contrôle
ComboBox
Contrôle Label
Name lbComboBox
Caption Sélection d’une valeur
Contrôle ComboBox
Name cbComboBox
Value
Contrôle CommandButton
Name cmdQuitter
Value Quitter
Développer des interfaces utilisateur
404 Troisième partie
Private Sub cmdQuitter_Click()
fmComboBox.Hide
End Sub
Exécutez ce code. Déroulez la liste modifiable pour visualiser les options disponibles (voir
figure 15-13). Pour fermer la feuille, cliquez sur le bouton Quitter.
Info
Utilisez la méthode RemoveItem pour supprimer des éléments d’une liste.
La propriété RowSource
Les éléments de la liste peuvent aussi être affectés au contrôle grâce à RowSource. Cette propriété
accepte pour valeur une chaîne représentant une cellule ou une plage de cellules. Cette possibi-
lité est très pratique lorsqu’un projet est affecté à un document contenant des données variables.
La liste reflète ainsi toujours les données de la feuille lorsque celles-ci sont modifiées.
Dans l’exemple suivant, une feuille VBA est créée permettant à l’utilisateur d’entrer des infor-
mations sur les chiffres des différents vendeurs d’une société. Un ComboBox sert à sélectionner le
vendeur. Pour réaliser cet exemple, créez une feuille de calcul Excel et saisissez-y les données
apparaissant à la figure 15-14.
Maîtriser le comportement des contrôles
Chapitre 15
405
Accédez ensuite à Visual Basic Editor (Alt+F11) et sélectionnez le projet attaché au nouveau
document dans l’Explorateur de projet. Créez une feuille VBA et placez-y un Label, un ComboBox
et un CommandButton avec les propriétés suivantes :
Propriété Valeur
Feuille
Name fmRowSource
Caption Utilisation de la propriété
RowSource
Contrôle Label
Name lbComboBox
Caption Sélectionnez un vendeur
Contrôle ComboBox
Name cbComboBox
Value
RowSource A2:A6
Contrôle CommandButton
Name cmdQuitter
Value Quitter
La définition de la propriété RowSource affecte le contenu des cellules A2 à A6 de la feuille Excel
à la liste du contrôle.
Ajoutez le code suivant dans la section Déclarations de la fenêtre Code de la feuille :
Private Sub cmdQuitter_Click()
fmRowSource.Hide
End Sub
Le ComboBox reflète ainsi le contenu des cellules A2 à A6. Si vous ajoutez des vendeurs (en A7,
puis A8, etc.), ils n’apparaîtront pas dans la liste déroulante du contrôle. Pour remédier à ce pro-
blème, il faut définir une procédure qui affecte à RowSource une plage de cellules variable, reflet
des cellules contenant des informations. Redéfinissez la propriété RowSource du ComboBox à une
chaîne vide, puis ajoutez la procédure suivante dans la section Déclarations de la fenêtre Code
de la feuille :
Private Sub UserForm_Initialize()
Dim DerCell As String
DerCell = Range("A1").End(xlDown).Address
cbComboBox.RowSource = "A2:" & DerCell
End Sub
Info
Utilisez la propriété ControlSource pour affecter la valeur sélectionnée par l’utilisateur dans un ComboBox
à une cellule d’une feuille de classeur.
ListBox
Les contrôles ListBox et ComboBox partagent nombre de propriétés (RowSource, ControlSource,
BoundColumn, etc.) et de méthodes (AddItem et RemoveItem, par exemple). Pour affecter une liste à
un ListBox, utilisez l’une des méthodes présentées pour les ComboBox.
Un ListBox peut n’autoriser la sélection que d’un élément de la liste, ou autoriser des choix mul-
tiples (avec différentes méthodes de sélection).
Le type de sélection d’un ListBox est déterminé par sa propriété MultiSelect, qui accepte pour
valeur l’une des constantes fmMultiSelect :
• fmMultiSelectSingle (par défaut). Un seul élément peut être sélectionné.
• fmMultiSelectExtended. Plusieurs éléments peuvent être sélectionnés avec les touches Maj
ou Ctrl. Un clic sur un élément de la liste, sans qu’aucune de ces touches ne soit enfoncée,
désélectionne tous les autres éléments.
• fmMultiSelectMulti. Plusieurs éléments peuvent être sélectionnés ou désélectionnés par de
simples clics, sans modifier l’état des autres éléments de la liste.
L’exemple suivant inscrit dans la fenêtre Exécution les éléments sélectionnés dans une liste.
Placez un Label, un ListBox et un CommandButton sur une feuille, dotés des propriétés suivantes :
Propriété Valeur
Feuille
Name fmListBox
Caption Valeurs sélectionnées dans la liste
Contrôle Label
Name lbMembres
Caption Membres présents
Contrôle ListBox
Name cbMembres
Value
MultiSelect fmMultiSelectMulti
Contrôle CommandButton
Name cmdValider
Caption Valider
cbMembres.AddItem "Lemaire"
cbMembres.AddItem "Leroux"
cbMembres.AddItem "Martin"
cbMembres.AddItem "Opéra"
cbMembres.AddItem "Otello"
End Sub
Private Sub cmdValider_Click()
Dim compteur As Single
For compteur = 0 To (cbMembres.ListCount-1)
If cbMembres.Selected(compteur)=True Then
Debug.Print cbMembres.List(compteur)
End If
Next compteur
fmListBox.Hide
End Sub
La première procédure affecte une liste au ListBox à l’affichage de la feuille. La procédure cmd-
Valider_Click utilise les propriétés suivantes du ListBox :
• ListCount renvoie le nombre d’éléments de la liste.
• Selected(index) renvoie une valeur booléenne indiquant si l’élément à la position index est
sélectionné.
• List(index) renvoie la chaîne de caractères correspondant à l’élément à la position index.
Une boucle For…Next est utilisée pour tester la valeur de chacun des éléments de la liste (le premier
ayant pour index 0, l’index du dernier est égal au nombre total d’éléments de la liste, moins 1).
Si l’élément testé est sélectionné, l’instruction Debug.Print en affiche le nom dans la fenêtre
Exécution de Visual Basic Editor. Enfin, la méthode Hide est appliquée à la feuille afin de le fermer.
Exécutez la feuille. Sélectionnez les éléments de votre choix dans la liste, puis cliquez sur le bouton
Valider. La feuille se ferme. Affichez la fenêtre Exécution de Visual Basic Editor (Ctrl+G). Les
éléments sélectionnés dans la liste y sont inscrits (voir figure 15-19).
CheckBox et OptionButton
Le CheckBox est d’une utilisation simple. Pensez à utiliser ses propriétés Enabled et Visible pour en
modifier l’accessibilité, en fonction des informations entrées par l’utilisateur. Vous pouvez aussi
modifier la propriété Caption, afin d’en faire varier la fonction. Pour un exemple d’utilisation de
ce contrôle, reportez-vous à la section consacrée à la propriété Enabled, au chapitre précédent.
Pour associer des OptionButton, soit vous les placez sur un même Frame, soit vous leur affectez une
même propriété GroupName. Reportez-vous à la section dédiée à cette propriété. Pour un exemple
d’exploitation des OptionButton, reportez-vous à la section consacrée à la propriété Visible.
ScrollBar
L’exemple suivant utilise un TextBox et un ScrollBar pour permettre à l’utilisateur de rechercher
les années bissextiles comprises entre l’an 0 et l’an 3000. L’utilisateur peut se déplacer par cent
années en cliquant dans la barre de défilement. Placez un TextBox et un ScrollBar sur une feuille,
avec les propriétés suivantes :
Propriété Valeur
Feuille
Name fmAnnéesBissextiles
Caption Les années bissextiles
Contrôle TextBox
Name txtAnnée
Value L’an 2000 est une année bissextile
Locked True
Contrôle ScrollBar
Name scrAnnée
Value 2000
Min 0
Max 3000
SmallChange 4
LargeChange 100
La procédure scrAnnée_Change sera déclenchée chaque fois que l’utilisateur modifiera l’emplace-
ment du curseur sur le ScrollBar. Elle affecte à varAnnée la valeur définie par le curseur (propriété
Value de scrAnnée). La propriété Value du TextBox est ensuite définie et la zone d’édition affiche
que varAnnée est une année bissextile.
Maîtriser le comportement des contrôles
Chapitre 15
411
Exécutez la feuille (figure 15-20). La barre de défilement modifie l’année affichée dans la zone
de texte. Lorsque vous cliquez sur l’une des flèches de défilement, la valeur du contrôle est incré-
mentée ou décrémentée de 4 (SmallChange). Lorsque vous cliquez dans la barre, entre le curseur
et une des flèches, cette valeur est incrémentée ou décrémentée de 100 (LargeChange).
Ce programme fonctionne bien tant que l’utilisateur déplace le curseur en cliquant sur l’une des
flèches de la barre de défilement, ou à l’intérieur de celle-ci. En revanche, s’il fait glisser le curseur,
la valeur de scrAnnée n’est plus maîtrisée par le programme et l’utilisateur peut sélectionner une
année qui n’est pas bissextile.
Partant du constat que toute année bissextile divisée par 4 est égale à un nombre entier et que
tout nombre multiple de 4 correspond à une année bissextile, vous pouvez exploiter la condition
suivante pour vérifier la valeur du contrôle :
Int(scrAnnée.Value/4) = scrAnnée.Value/4
La boucle While…Wend décrémente la valeur de scrAnnée tant que la condition posée n’est pas res-
pectée (While Not) – la boucle s’exécute donc au maximum trois fois. Ainsi, si l’utilisateur opère
un glisser-déplacer du curseur de défilement, nous sommes assurés que la valeur de scrAnnée sera
modifiée si nécessaire, afin de correspondre à une année bissextile.
Développer des interfaces utilisateur
412 Troisième partie
SpinButton
Dans l’exemple suivant, un SpinButton est placé à côté d’un TextBox et permet de sélectionner sept
valeurs. Un jour de la semaine est affecté à chacune des sept valeurs possibles et affiché dans la
zone de texte. Placez un TextBox et un SpinButton sur une feuille et attribuez-leur les propriétés
suivantes :
Propriété Valeur
Feuille
Name fmJour
Caption Choix du jour
Contrôle TextBox
Name txtJour
Value Lundi
Locked True
Contrôle SpinButton
Name spbJour
Value 7
Min 1
Max 7
SmallChange 1
Exécutez la feuille (figure 15-21). Le bouton toupie modifie le jour affiché dans la zone de texte.
Lorsqu’on arrive à Dimanche, la flèche de défilement Bas est sans effet. Lorsque Lundi est affiché,
la flèche Haut est sans effet.
Attention
Lorsque la propriété Value d’un ScrollBar ou d’un SpinButton est égale à sa propriété Max ou Min, redé-
finir la valeur de l’une de ces dernières dans la fenêtre Propriétés entraîne aussi la redéfinition de Value.
Dans le cas présent, l’affectation de la valeur 8 à Max redéfinira aussi Value à 8. Vous devez par consé-
quent changer Value à 7 après avoir modifié Max.
Développer des interfaces utilisateur
414 Troisième partie
La structure conditionnelle ajoutée teste la valeur de spbJour. Si l’utilisateur clique sur la flèche
de défilement Haut du bouton toupie alors que sa valeur est 1 (la zone de texte affiche Dimanche),
Value passe à 0 (Min) et la structure conditionnelle (lignes 2 et 3) la redéfinit à 7 (Max-1). De même, si
l’utilisateur clique sur la flèche de défilement Bas alors que la valeur est 7 (la zone de texte affiche
Lundi), Value passe à 8 (Max) et la structure conditionnelle (lignes 4 et 5) la redéfinit à 1 (Min+1).
Info
La procédure conditionnelle gérant les valeurs en boucle du bouton toupie peut tout aussi bien s’écrire
ainsi :
If spbJour.Value=spbJour.Min Then
spbJour.Value = spbJour.Max-1
ElseIf spbJour.Value = spbJour.Max Then
spbJour.Value = spbJour.Min + 1
End If
Rappel
Les appels de procédure et le passage d’arguments ont été traités au chapitre 5.
Lorsque vous souhaitez développer une interface utilisateur pour simplifier une tâche, procédez
selon les étapes suivantes :
1. Développez votre feuille. Déterminez les propriétés des différents contrôles et écrivez les
procédures événementielles qui leur sont spécifiques.
2. Dans un module de code, écrivez une procédure qui affichera la feuille (NomFeuille.Show). Vous
pourrez éventuellement l’affecter par la suite à un bouton de barre d’outils ou à une commande
de menu (voir chapitre 12), de façon à simplifier l’exécution du programme.
3. Votre feuille contiendra probablement un bouton de validation (OK). La procédure événemen-
tielle pour l’événement Click de ce bouton devra :
– vérifier que les informations entrées par l’utilisateur sont valides ;
– masquer la feuille (Me.Hide) ;
– appeler la procédure qui traitera les informations.
La procédure événementielle suivante appelle ValidationConditions en lui passant pour
arguments les valeurs des contrôles TxtVolume, TxtPrixTrad, TxtPrixAudio, ChkDefinitif et
ChkImprimer.
Maîtriser le comportement des contrôles
Chapitre 15
415
Private Sub CmdOK_Click()
'Instructions vérifiant la validité des données
Me.Hide
Call ValidationConditions(TxtVolume.Value, TxtPrixTrad.Value, _
TxtPrixAudio.Value, ChkDefinitif.Value, ChkImprimer.Value)
End Sub
Conseil
Si vous devez recueillir de nombreuses informations, créez plusieurs feuilles VBA et structurez-les de la
façon suivante :
1. Affichage de la première feuille.
2. Stockage de ses données dans des variables d’un module de code.
3. Masquage de la feuille
4. Affichage de la seconde feuille et retour au point 2.
Etc.
N. Appel de la procédure en charge de traiter les données entrées dans les différentes feuilles.
Quatrième partie
Notions
avancées
de la
programmation
Excel
16
Programmer
des événements Excel
Vous avez découvert, au cours de cet ouvrage, l’environnement de Visual Basic Editor, les tech-
niques de programmation en VBA et les outils d’aide au développement de projet. Ce chapitre
vous apprendra à gérer précisément les événements utilisateur susceptibles d’affecter les objets
Excel au cours d’une utilisation classique du logiciel. Vous verrez qu’il est possible de détecter
les actions de l’utilisateur sur un classeur et de créer des procédures affectées à ces événements.
Au même titre que les contrôles placés sur une feuille UserForm, les classeurs et les feuilles
Excel sont des objets auxquels vous pouvez affecter des procédures événementielles. Vous gérez
ainsi des événements tels que la création d’un nouveau classeur, la modification d’une cellule,
l’activation d’une feuille, etc.
L’objet Application
Au sommet du modèle d’objets d’Excel se trouve Application. Il représente l’ensemble de l’appli-
cation et est donc l’objet conteneur de tous les autres. L’objet Application est particulièrement
intéressant pour le développeur. Il intègre en effet la gestion d’événements de niveau application,
susceptibles d’intervenir lors d’une utilisation courante du tableur : création, ouverture ou fer-
meture d’un classeur, etc.
Les sections suivantes vous indiquent comment créer des procédures événementielles pour l’objet
Application.
Notions avancées de la programmation Excel
420 Quatrième partie
Info
Le mot-clé WithEvents n’est valide que dans un module de classe.
Notre projet intègre maintenant un module de classe dans lequel nous avons défini un objet
MaVarApplication de type Application, capable de gérer les événements. Nous devons maintenant
en créer une instance et lui affecter l’objet Application d’Excel. Cette procédure peut se trouver
dans n’importe quel module de code.
Supposons ici que vous souhaitiez que la gestion des événements de niveau application soit active
dès l’ouverture d’Excel. Il vous suffit d’écrire l’instruction d’instanciation de la variable dans une
procédure événementielle affectée à l’ouverture du classeur PERSONAL.XLSB.
Procédez comme suit :
1. Dans l’Explorateur de projet, double-cliquez sur l’objet ThisWorkbook du projet PERSONAL.
XLSB. Sa fenêtre Code s’affiche. Dans la section Déclaration, placez l’instruction suivante :
Dim MonInstance As New ModuleGestionEvt
où ModuleGestionEvt est le nom affecté au module de classe créé dans la section précédente.
2. Dans la zone Objet de la fenêtre Code, sélectionnez Workbook. Les instructions d’encadrement
d’une procédure événementielle de type Open sont automatiquement créées. Placez entre celles-
ci l’instruction d’affectation de la variable MonInstance. La procédure doit se présenter comme
suit :
Private Sub Workbook_Open()
Set MonInstance.MaVarApplication = Application
End Sub
• L’argument Wb correspond à l’objet Workbook créé. Vous pouvez utiliser cette variable dans votre
procédure pour tester et manipuler le classeur créé. L’instruction suivante affiche une boîte de
dialogue dans laquelle est mentionné le nombre de feuilles du classeur :
MsgBox "Le classeur contient " & Wb.Sheets.Count & " feuilles."
La reconnaissance de l’événement NewWorkbook est utile pour créer des procédures destinées à aider
l’utilisateur dans ses tâches courantes. Vous pouvez par exemple afficher une feuille UserForm
contenant une liste d’options de classeurs : l’utilisateur sera alors invité à indiquer le type de
classeur qu’il souhaite réaliser et la procédure appelée insérera les données essentielles, créera
le nombre de feuilles voulues, enregistrera le classeur dans le bon dossier, etc.
La liste Procédure recense les événements gérés par l’objet Application. Vous y trouverez notam-
ment WindowActivate (activation d’une fenêtre par l’utilisateur), ou encore WorkbookBeforePrint
(survient avant l’exécution d’une impression). Les événements dont le nom contient la chaîne
Before surviennent avant l’exécution d’une tâche. Ils intègrent le plus souvent un argument Cancel
permettant d’annuler cette dernière si les conditions requises ne sont pas remplies. Les événements
dont le nom contient la chaîne After surviennent après l’exécution d’une tâche.
Notions avancées de la programmation Excel
422 Quatrième partie
Propriété Description
ActiveWorkbook Renvoie l’objet Workbook correspondant au classeur actif (en lecture seule).
ActiveSheet Renvoie l’objet Worksheet correspondant à la feuille active du classeur spécifié (en lecture
seule).
ActiveCell Renvoie l’objet Range correspondant à la cellule active de la feuille de classeur spécifiée
(en lecture seule).
Caption Renvoie le nom de l’application, qui apparaît dans la barre de titre. La valeur par défaut
est "Microsoft Excel". La figure 15-2 représente une session Excel dans laquelle nous
avons redéfini la valeur de la propriété Caption de l’objet Application (Application.
Caption = ChaîneTitre).
Cursor Définit l’apparence du curseur au cours des différentes phases d’une macro. Quatre
constantes correspondent aux quatre curseurs disponibles. Si vous modifiez l’apparence du
curseur au cours d’une macro, n’oubliez pas de redéfinir la propriété Cursor à xlDefault à
la fin de l’exécution.
DisplayAlerts Paramétrez cette propriété sur False pour éviter l’affichage de messages Excel. N’omettez
pas de redéfinir la propriété DisplayAlerts sur True en fin de macro.
DisplayFormulaBar, Déterminent respectivement si les barres de formule, de défilement et d’état sont affichées
DisplayScrollBars (True) ou non (False).
et DisplayStatusBar
EnableCancelKey Détermine si l’utilisateur peut ou non interrompre une macro en cours d’exécution à l’aide
de la combinaison Ctrl+Pause. Par défaut, sa valeur est xlInterrupt. Pour interdire
l’interruption, définissez cette propriété sur xlDisabled ou sur xlErrorHandler.
PathSeparator Renvoie le caractère utilisé comme séparateur dans les chemins – une barre oblique
inverse (\) sous Windows et deux-points (:) sous Macintosh. Cette propriété est utile si vous
développez des projets VBA tournant sur les deux systèmes.
ScreenUpdating Détermine si l’affichage écran est mis à jour (True) ou non (False) lors de l’exécution d’une
macro. Ne pas le mettre à jour améliore considérablement les performances. De plus, les
tâches effectuées sont invisibles pour l’utilisateur tant que la macro n’est pas terminée.
La propriété ScreenUpdating est automatiquement redéfinie à True lorsque la macro
s’achève.
ThisWorkbook Renvoie le classeur contenant le code de la macro qui s’exécute. Il ne s’agit pas forcément
du classeur actif (ActiveWorkbook).
UserName Détermine le nom d’utilisateur. Il s’agit par défaut du nom apparaissant dans l’onglet
Général de la boîte de dialogue Options.
Programmer des événements Excel
Chapitre 16
423
Attention
Lorsque vous modifiez les propriétés de l’objet Application au cours d’une macro, pensez à les redéfinir
à la fin de l’exécution.
Si vous définissez EnableCancelKey à False, vous devez être certain que votre macro n’est pas boguée
et gère les exceptions. Si, par exemple, elle exécute une boucle à l’infini, vous n’aurez aucun moyen de
l’interrompre.
Méthode Description
Calculate Effectue un calcul forcé sur tous les classeurs ouverts. Utilisez cette méthode pour mettre à
jour les classeurs ouverts lorsque le tableur est paramétré pour effectuer des calculs manuels
(onglet Calcul de la boîte de dialogue Options).
OnKey Exécute une procédure lorsqu’une combinaison de touches est activée. Pour plus d’informations,
consultez l’aide en ligne de VBA.
OnTime Programme l’exécution d’une procédure à un moment précis (ce soir à 20 h 30 par exemple).
Pour plus d’informations, consultez l’aide en ligne de VBA.
OnUndo Définit le texte placé derrière la commande Annuler du menu Édition et la procédure exécutée
lorsque l’utilisateur sélectionne cette commande. Pour plus d’informations, consultez l’aide
en ligne de VBA.
Notions avancées de la programmation Excel
424 Quatrième partie
L’objet ThisWorkbook
Disponible dans le dossier Microsoft Excel Objets de l’Explorateur de projet, l’objet ThisWorkbook
représente le classeur correspondant au projet affiché dans l’Explorateur de projet (voir figure 16-3).
Au même titre que l’objet Application, il intègre des propriétés et des méthodes pour le manipuler
et se renseigner sur son état. Il prend aussi en charge un certain nombre d’événements.
Double-cliquez sur ThisWorkbook dans l’Explorateur de projet. Dans la zone Objet de la fenêtre
Code, sélectionnez Workbook. Les instructions d’encadrement d’une procédure événementielle
Open (ouverture du classeur) sont automatiquement insérées.
Les Feuilles
de calcul
Le classeur
Figure 16-3 – Les objets du dossier Microsoft Excel Objets correspondent au classeur et à ses feuilles de calcul.
ThisWorkbook est un objet Workbook (classeur). Il possède donc les mêmes propriétés et les mêmes
méthodes que tous les objets de ce type. Il prend en charge un nombre important d’événements,
tels que Open (ouverture du classeur) ou SheetActivate (activation d’une autre feuille de calcul).
Certains prennent des arguments précisant l’action de l’utilisateur. Par exemple, SheetActivate
prend pour argument un objet Worksheet qui correspond à la feuille activée.
Pour une liste détaillée des propriétés, méthodes et événements de ces objets, saisissez Workbook
dans une fenêtre Code, sélectionnez ce mot et appuyez sur la touche F1.
Ouvrez n’importe quel classeur Excel. Ouvrez la fenêtre Code de l’objet ThisWorkbook du projet
et placez-y le code suivant :
Private Sub Workbook_SheetActivate(ByVal Sh As Object)
MsgBox "La feuille " & Sh.Name & " a été activée.", _
vbOKOnly + vbInformation, "Evénement SheetActivate détecté"
End Sub
Programmer des événements Excel
Chapitre 16
425
Retournez dans Excel ; à chaque fois que vous activez une feuille, une boîte de dialogue affiche
son nom. Cette fonction est intéressante si vous souhaitez limiter l’accès à une feuille de calcul.
La procédure suivante affiche une boîte de dialogue dans laquelle l’utilisateur est invité à entrer
un mot de passe s’il tente d’accéder à la feuille « Clients ».
Private Sub Workbook_SheetActivate(ByVal Sh As Object)
Application.EnableCancelKey = xlDisabled
If Sh.Name="Clients" Then
ActiveWindow.Visible = False
Dim MotDePasse As String
MotDePasse = InputBox("Entrez votre mot de passe.", _
"Mot de passe requis")
If Not MotDePasse="jk85m" Then
MsgBox "Le mot de passe saisi est incorrect.", _
vbOKOnly + vbInformation, "Mot de passe incorrect"
ThisWorkbook.Sheets("Feuil2").Activate
End If
Windows("Representants par clients.xlsx").Visible = True
End If
End Sub
Notez que nous avons défini la propriété EnableCancelKey de l’objet Application à xlDisabled,
de façon que l’utilisateur ne puisse pas interrompre la macro. La propriété Visible de l’objet
ActiveWindow (la fenêtre active) est définie à False de manière à masquer la feuille de classeur
tant que l’utilisateur n’a pas entré le mot de passe. Si l’utilisateur saisit un mauvais mot de passe,
la feuille Feuil2 du classeur est activée. Enfin, la propriété Visible de la fenêtre correspondant
au classeur est définie à True de façon à afficher de nouveau le classeur.
Rappel
Pour empêcher l’utilisateur de lire le mot de passe dans Visual Basic Editor, protégez aussi votre projet par
mot de passe.
L’objet Worksheet
Le dossier Microsoft Excel Objets contient aussi des objets Worksheet correspondant aux feuilles
du classeur (voir figure 16-3).
Les feuilles gèrent les événements présentés dans le tableau 16-3. Pour accéder aux rubriques
d’aide d’un événement, ouvrez la fenêtre Code d’un objet Feuille, choisissez l’événement voulu
dans la liste Procédure, sélectionnez son nom et appuyez sur la touche F1.
Événement Description
Activate Survient lorsque la feuille de calcul est activée.
BeforeDoubleClick Survient avant le double-clic sur une feuille de calcul ou un graphique. La procédure
reçoit l’objet Range correspondant à la cellule sur laquelle l’utilisateur a double-cliqué.
Utilisez l’argument Cancel pour annuler si nécessaire.
BeforeRightClick Survient avant que le clic-droit ne soit validé. La procédure reçoit l’objet Range
correspondant à la cellule sur laquelle l’utilisateur a cliqué-droit. Utilisez l’argument Cancel
pour annuler si nécessaire.
Calculate Survient lorsqu’un calcul est effectué. C’est le cas si Excel est paramétré pour un calcul
automatique et si la valeur d’une cellule utilisée comme argument dans des fonctions de
la feuille est modifiée. Si Excel est paramétré pour un calcul manuel, l’événement survient
lorsque l’utilisateur force le calcul.
Change Survient lorsque la valeur d’une cellule est modifiée (on considère que c’est le cas
après que l’utilisateur a sélectionné une autre cellule). La procédure reçoit l’objet Range
correspondant à la cellule dont la valeur a été changée.
Deactivate Survient lorsque la feuille de calcul est désactivée, c’est-à-dire lorsque l’utilisateur en
sélectionne une autre.
SelectionChange Survient lorsque l’utilisateur modifie la cellule ou la plage de cellules sélectionnée.
La procédure reçoit l’objet Range correspondant.
La procédure suivante affiche une boîte de dialogue invitant l’utilisateur à mettre à jour les
classeurs liés s’il modifie la valeur de la cellule B5 de la feuille en cours. S’il clique sur le
bouton Oui, ProcédureMiseAJour est appelée et la valeur de la cellule B5 lui est passée comme
argument.
Programmer des événements Excel
Chapitre 16
427
Figure 16-5 – S’il modifie la valeur de la cellule B5, l’utilisateur est invité à mettre à jour les classeurs liés.
Attention
Notez que les fenêtres Code des objets Workbook et Worksheet ne peuvent contenir que des procédures
événementielles. Les procédures appelées doivent se trouver dans des modules de code.
Pour une liste détaillée des propriétés, méthodes et événements des feuilles, saisissez Worksheet
dans une fenêtre Code, sélectionnez ce mot et appuyez sur la touche F1.
17
Protéger et authentifier
des projets VBA
Figure 17-1 – Définissez les options de sécurité d’Excel dans cette fenêtre.
Protéger et authentifier des projets VBA
Chapitre 17
431
▸ Désactiver toutes les macros à l’exception des macros signées numériquement : celles
situées à un emplacement autorisé ou signées numériquement par un éditeur approuvé
seront automatiquement activées. Dans le cas contraire, l’utilisateur pourra choisir de
les activer ou non.
▸ Activer toutes les macros : elles seront toutes activées sans aucun contrôle du Centre
de confidentialité. Pratique lorsque vous développez des projets VBA, cette option est
déconseillée avec les documents provenant de sources extérieures.
– Mode protégé. Il ouvre les fichiers potentiellement dangereux en en désactivant les macros.
– Barre des messages. Zone où un potentiel message s’affiche lorsque le contenu actif d’un
document ouvert est désactivé.
– Contenu externe. On définit ici le comportement d’Excel lorsque les macros établissent des
connexions avec des sources externes, c’est-à-dire avec d’autres fichiers. Il peut s’agir de
fichiers Excel ou d’autres types de données.
Astuce
Pour un accès direct à ces options, cliquez sur le bouton Sécurité des macros de l’onglet Développeur.
Notions avancées de la programmation Excel
432 Quatrième partie
Figure 17-3 – Les signatures numériques considérées comme sources fiables apparaissent ici.
Conseil
Choisissez un niveau de sécurité adapté à vos utilisateurs et à votre usage des macros. Si vous travaillez
dans une entreprise qui développe ses propres macros et n’utilise a priori pas de sources extérieures,
optez pour la signature associée à un niveau de sécurité haut. C’est également le bon choix pour des utili-
sateurs qui ne sont pas conscients des dangers liés aux virus macros.
En revanche, si vous utilisez des macros provenant de sources extérieures variables, le niveau de sécurité
élevé entraînerait la désactivation de toutes celles qui ne sont pas signées, sans que l’utilisateur ne soit
prévenu de leur existence. Un niveau moyen se révélera alors plus adapté, à condition de sensibiliser les
utilisateurs aux dangers des virus macros et de fixer des règles pour leur activation.
Le niveau de sécurité bas ne devrait être appliqué que dans des conditions exceptionnelles ; par exemple,
si vous ne disposez pas d’une signature numérique et développez un nombre important de macros que
vous souhaitez toujours activées.
Protéger et authentifier des projets VBA
Chapitre 17
433
Le fichier sauvegardé est importable dans n’importe quel projet : affichez la fenêtre de l’Explora-
teur de projet, cliquez-droit sur l’un des éléments et choisissez la commande Importer un fichier.
Sélectionnez ensuite le fichier (.bas, .frm ou .cls).
Verrouiller un projet
Si d’autres utilisateurs accèdent à vos macros, un simple mot de passe empêchera qu’ils en voient/
modifient le code. Pour verrouiller un projet, procédez comme suit :
1. Affichez l’Explorateur de projet.
2. Cliquez-droit sur le nom du projet et ouvrez ses propriétés.
3. Activez l’onglet Protection et cochez la case Verrouiller le projet pour l’affichage (voir
figure 17-5).
4. Dans les zones définies à cet effet, saisissez à deux reprises le mot de passe qui sera ensuite
demandé pour accéder au projet, puis validez.
Le verrouillage du projet prendra effet dès la prochaine ouverture du document. Le mot de passe
est nécessaire pour accéder au code du projet ou pour supprimer une macro (voir figure 17-6).
Protéger et authentifier des projets VBA
Chapitre 17
435
Figure 17-6 – Le mot de passe est maintenant requis pour accéder au code du projet.
Attention
Si vous oubliez le mot de passe défini au moment du verrouillage, vous n’aurez plus aucun moyen d’ac-
céder au code. Il est fortement recommandé d’effectuer une sauvegarde du projet ou d’en exporter les
modules et les feuilles avant de le protéger par mot de passe.
Propriété Valeur
Feuille
Name fmMotDePasse
Caption Entrez le mot de passe.
Contrôle Label
Name lbMotdePasse
Caption Entrez ci-après le mot de passe requis pour l’exécution de cette
commande.
Contrôle TextBox
Name txtMotDePasse
PasswordChar *
Contrôle CommandButton 1
Name cmdOK
Caption OK
Default True
Contrôle CommandButton 2
Name cmdAnnuler
Caption Annuler
Cancel True
Pour tester ce programme, insérez la procédure suivante dans n’importe quel module de code
et exécutez-la.
Sub TestMotDePasse()
fmMotDePasse.Show
MsgBox "Si ce message s'affiche, c'est que le programme se poursuit."
End Sub
Cette procédure appelle la feuille de vérification du mot de passe (fmMotDePasse). Elle ne reprendra
la main que si le mot de passe entré dans la feuille est correct ; elle affichera alors un message
indiquant que le code se poursuit.
La première procédure (lignes 1 à 4) s’exécute à chaque affichage de la feuille. Elle affecte une
chaîne vide à la zone de texte et lui passe le focus.
La procédure suivante (lignes 6 à 11) s’exécute lorsque l’utilisateur clique sur le bouton Annuler
ou tape sur la touche Échap. La feuille est alors déchargée et un message informe l’utilisateur que
la commande prend fin. L’instruction End met fin à l’exécution du programme.
La procédure cmdOK_Click se déclenche lorsque l’utilisateur clique sur le bouton OK ou tape sur
la touche Entrée quand ce dernier a le focus. Lignes 15 à 22, une structure conditionnelle If…
Then…Else vérifie que le mot de passe entré est correct, c’est-à-dire que l’utilisateur a saisi ftg87
(ligne 15) dans la zone de texte. Si tel est le cas, la feuille est déchargée et la procédure ayant
appelé l’affichage de la feuille reprend la main. Dans le cas contraire, un message indique à
l’utilisateur que le mot de passe entré est incorrect. La zone de texte est alors vidée de la valeur
précédemment entrée et reprend le focus.
Attention
Lignes 7 et 16, nous avons utilisé le mot-clé Unload et non Hide pour faire disparaître la feuille. Rappe-
lez-vous que Hide masque la feuille mais ne libère pas les ressources mémoire qu’elle exploite. Si vous
remplacez l’instruction Unload Me de la ligne 16 par l’instruction Me.Hide, la prochaine fois que la feuille
sera affichée au cours de la session, le mot de passe précédemment saisi sera toujours dans la zone de
texte. Il suffira alors à l’utilisateur de cliquer sur le bouton OK pour exécuter la macro.
Le programme présente ici un bogue grave : si l’utilisateur clique sur la croix de fermeture de la
fenêtre, aucun événement n’est détecté. La feuille se ferme et le programme se poursuit, comme
Notions avancées de la programmation Excel
438 Quatrième partie
si le mot de passe avait été fourni. Pour remédier à ce problème, ajoutez la procédure suivante
au code de la feuille :
Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
If CloseMode=vbFormControlMenu Then
Me.Hide
MsgBox "Cette commande ne peut être exécutée sans le mot de passe.", _
vbOKOnly + vbExclamation, "Fin de la commande"
End
End If
End Sub
L’événement QueryClose est détecté lorsqu’on tente de fermer la fenêtre. L’argument Cancel sert à
annuler la fermeture. L’argument CloseMode indique la cause de l’événement ; ici, un clic sur le bou-
ton de fermeture de la fenêtre (vbFormControlMenu). Si vous ne précisez pas CloseMode, la procédure
s’exécutera dans n’importe quel contexte, y compris lorsque la méthode Unload sera utilisée dans
le code. Dans ce cas, si l’utilisateur clique sur le bouton Annuler, le message l’informant que le
programme prend fin sera affiché à deux reprises – dans le cadre des procédures événementielles
cmdAnnuler_Click et UserForm_QueryClose.
Dans ce premier exemple, la feuille reste affichée jusqu’à ce que l’utilisateur entre le mot de
passe correct ou qu’il clique sur le bouton Annuler. Vous pouvez également choisir de limiter
le nombre d’essais. La procédure cmdOK_Click reproduite ci-après a été modifiée de sorte que le
programme prenne fin après trois tentatives infructueuses de saisie du mot de passe. Nous avons
également redéfini la propriété Caption de la feuille à «Entrez le mot de passe. Tentative 1 sur 3»
et modifié le code de manière que cette information soit mise à jour dans la barre de titre de la
fenêtre à chaque nouvelle tentative.
1: Private Sub cmdOK_Click()
2: 'La variable compteur servira à compter le nombre de tentatives.
3: Static compteur As Byte
4: compteur = compteur + 1
5:
6: If txtMotDePasse.Text="ftg87" Then
7: Unload Me
8: Else
9:
10: 'Si c'est la 3e fois que l'utilisateur entre un mot
11: 'de passe incorrect, le programme prend fin.
12: If compteur=3 Then
13: MsgBox "Echec dans la saisie du mot de passe." & _
14: vbCr & "La commande ne peut être exécutée", _
15: vbOKOnly + vbExclamation, "Mot de passe incorrect"
16: End
17: End If
18:
19: MsgBox "Le mot de passe fourni n'est pas correct.", _
20: vbOKOnly + vbExclamation, "Mot de passe incorrect"
21: txtMotDePasse.Value = ""
Protéger et authentifier des projets VBA
Chapitre 17
439
22: txtMotDePasse.SetFocus
23: Me.Caption = "Entrez le mot de passe. Tentative " & _
24: compteur+1 & " sur 3"
25:
26: End If
27: End Sub
Exécutez la feuille. Lorsque vous saisissez un mot de passe incorrect, un message vous en informe
et le titre de la fenêtre est mis à jour de façon à refléter le nombre de tentatives (voir figure 17-8).
Si l’utilisateur saisit trois fois de suite un mot de passe erroné, un message l’informe que le pro-
gramme ne peut être exécuté et la macro prend fin (voir figure 17-9).
La barre de titre indique le nombre de tentatives effectuées
La variable compteur est déclarée à l’aide du mot-clé Static et est incrémentée de 1 à chaque
exécution de la procédure, c’est-à-dire chaque fois que l’utilisateur valide un mot de passe. Notez
que nous n’avons pas intégré d’instruction affectant la valeur 0 à compteur ; cela aurait en effet
réinitialisé la variable à chaque exécution de la procédure, qui n’aurait alors jamais pris fin.
Rappel
Une variable statique conserve sa valeur entre les différents appels d’une procédure. Une variable statique
au sein d’un module de feuille conserve sa valeur tant que la feuille s’affiche.
Lignes 12 à 17, une structure If…Then…Else a été imbriquée dans la structure conditionnelle ini-
tiale. Elle vérifie si le compteur est égal à 3, c’est-à-dire si c’est la troisième fois que l’utilisateur
propose un mot de passe erroné. Si tel est le cas, un message s’affiche et l’instruction End de la
ligne 16 interrompt le programme.
Enfin, lignes 23 et 24, nous avons ajouté une instruction qui met à jour le texte affiché dans la
barre de titre de la fenêtre. Pour définir quel sera le numéro de la prochaine tentative, on incré-
mente la valeur de Compteur (le nombre de tentatives effectuées, y compris celle en cours) de 1.
Notions avancées de la programmation Excel
440 Quatrième partie
Telle qu’elle se présente dans les deux versions du programme que nous avons données ici, la
feuille fmMotDePasse permet d’exiger un mot de passe de l’utilisateur à tout moment de l’exécution
d’un programme. Il suffit pour cela de placer l’instruction :
fmMotDePasse.Show
Ce programme peut cependant être rendu plus souple et plus performant en contournant les
limitations à un mot de passe (ici ftg87) et à trois tentatives, toutes deux définies dans le code de
la feuille. Vous souhaiterez en effet probablement définir des mots de passe différents selon les
programmes et les utilisateurs.
La solution consiste à appeler une procédure de validation en lui passant les valeurs « mot de
passe » et « nombre de tentatives » comme arguments. Elle stockera ces valeurs dans des variables
publiques de niveau module auxquelles les autres procédures de la feuille accéderont.
Créez un nouveau module de code et affectez-lui un nom représentatif, par exemple MotDePasse.
Placez les instructions suivantes dans sa fenêtre de code :
1: Public varMotDePasse As String
2: Public varNumTentatives As Byte
3:
4: Sub ControleMotDePasse(MotDePasse As String, NumTentatives As Byte)
5: varMotDePasse = MotDePasse
6: varNumTentatives = NumTentatives
7: fmMotDePasse.Show
8: End Sub
Lignes 1 et 2 les variables de niveau module varMotDePasse et varNumTentatives sont déclarées
publiques. ControleMotDePasse (lignes 4 à 8) pourra être appelée par n’importe quelle procédure
en lui passant les arguments requis, afin de subordonner la poursuite de l’exécution du programme
en cours à la présentation d’un mot de passe par l’utilisateur. Cette procédure affecte les valeurs
qu’elle reçoit comme arguments aux variables varMotDePasse et varNumTentatives et appelle ensuite
la feuille fmMotDePasse.
Modifiez ensuite le code de la feuille de la façon suivante :
1: Private Sub UserForm_Initialize()
2: txtMotDePasse.Value = ""
3: txtMotDePasse.SetFocus
4: Me.Caption = "Entrez le mot de passe. Tentative 1" & _
5: " sur " & varNumTentatives
6: End Sub
7:
8: Private Sub cmdAnnuler_Click()
9: Me.Hide
10: MsgBox "Cette commande ne peut être exécutée sans le mot de passe.", _
11: vbOKOnly + vbExclamation, "Fin de la commande"
12: End
13: End Sub
14:
Protéger et authentifier des projets VBA
Chapitre 17
441
Partout dans le code où il était fait référence au nombre de tentatives ou au mot de passe, nous
avons remplacé les valeurs fixes par des références aux variables varMotDePasse et varNumTen-
tatives. Nous avons ajouté une instruction définissant le titre de la fenêtre dans la procédure
Initialize de la feuille (lignes 4 et 5), afin que le texte affiché dans la barre de titre reflète le
nombre de tentatives autorisées dès l’affichage de la feuille. Ce titre est ensuite mis à jour à chaque
passage de la fenêtre (ligne 38).
Ligne 20, la valeur de la zone de texte est maintenant comparée à celle stockée dans varMotDe-
Passe, tandis que, ligne 26, Compteur l’est à varNumTentatives.
Pour imposer la saisie d’un mot de passe, il suffit maintenant de placer l’instruction suivante à
l’endroit voulu :
Call ControleMotDePasse(MotDePasse, NumTentatives)
Notions avancées de la programmation Excel
442 Quatrième partie
Pour tester le programme, placez la procédure suivante dans n’importe quel module du projet et
exécutez-la (voir figure 17-10).
1: Sub TestControleMotDePasse()
2: Dim maVar As String
3: Call ControleMotDePasse("Bonjour", 1)
4: maVar = Application.UserName
5: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
6: vbOKOnly + vbInformation
7: Call ControleMotDePasse(maVar, 5)
8: maVar = Application.UserInitials & "-vba"
9: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
10: vbOKOnly + vbInformation
11: Call ControleMotDePasse(maVar, 6)
12: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
13: vbOKOnly + vbInformation
14: End Sub
Le nombre de tentatives
autorisé est défini lors de
l'appel de la procédure de
contrôle
Astuce
Vous pouvez également limiter le nombre de caractères autorisés dans la zone de texte à la longueur du
mot de passe attendu. Insérez pour cela l’instruction suivante dans la procédure UserForm_Initialize
de fmMotDePasse :
txtMotDePasse.MaxLength = Len(varMotDePasse).
Protéger et authentifier des projets VBA
Chapitre 17
443
Rappel
La propriété MaxLength est développée au chapitre 15.
Apportons une ultime amélioration au programme : autorisons plusieurs mots de passe pour
exécuter une macro. Cela sera nécessaire si vous définissez un mot de passe par « groupe d’uti-
lisateurs ». Vous limiterez par exemple l’accès à certaines macros aux utilisateurs du groupe
« Financier » et d’autres au groupe « Production ».
Voici les modifications à apporter au programme pour autoriser jusqu’à trois mots de passe
(module MotDePasse) :
1: Public varMotDePasse1 As String, varMotDePasse2 As Variant,
➥ varMotDePasse3 As Variant
2: Public varNumTentatives As Byte
3:
4: Sub ControleMotDePasse(NumTentatives As Byte, MotDePasse1 As String,
➥ Optional MotDePasse2 As String, Optional MotDePasse3 As String)
5: varNumTentatives = NumTentatives
6: varMotDePasse1 = MotDePasse1
7:
8: 'On vérifie si plusieurs mots de passe ont été passés,
9: 'et on affecte une valeur aux variables en conséquence.
10: If IsMissing(MotDePasse2)=True Then
11: varMotDePasse2 = MotDePasse1
12: Else
13: varMotDePasse2 = MotDePasse2
14: End If
15: If IsMissing(MotDePasse3)=True Then
16: varMotDePasse3 = MotDePasse1
17: Else
18: varMotDePasse3 = MotDePasse3
19: End If
20: fmMotDePasse.Show
21: End Sub
Ligne 1, nous avons créé trois variables destinées à recevoir les 3 mots de passe autorisés. Nous
avons ensuite modifié la déclaration de ControleMotDePasse (ligne 4) en y ajoutant les arguments
optionnels MotDePasse2 et MotDePasse3. Notez que nous avons dû déplacer l’argument Numtentatives
en début de liste car un argument optionnel ne peut être suivi d’un obligatoire.
Deux structures conditionnelles (lignes 10 à 14 et lignes 15 à 19) vérifient ensuite si les mots de
passe optionnels ont été passés. Si l’argument correspondant au deuxième mot de passe valide
a été passé, sa valeur est affectée à varMotDePasse2 ; sinon varMotDePasse2 vaut MotDePasse1. Le
même traitement est appliqué à varMotDePasse3.
Rappel
Le mot-clé Optional indique qu’un argument n’est pas obligatoire. La fonction IsMissing sert pour vérifier
si l’argument a été passé ou non.
Notions avancées de la programmation Excel
444 Quatrième partie
Attention
La fonction IsMissing ne fonctionne correctement qu’avec des arguments de type Variant. Si vous
déclarez les arguments MotDePasse2 et MotDePasse3 de type String, IsMissing renverra toujours
False. En conséquence, varMotDePasse2 et varMotDePasse3 se verront affecter une chaîne vide, qui
sera reconnue comme mot de passe valide.
Modifiez ensuite le test de la procédure cmdOK_Click de façon que chacun des trois mots de passe
autorisés soit reconnu comme valide :
If txtMotDePasse.Text=varMotDePasse1 Or txtMotDePasse.Text=varMotDePasse2
➥ Or txtMotDePasse.Text=varMotDePasse3 Then
Info
Grâce aux instructions des lignes 10 à 19, varMotDePasse2 et varMotDePasse3 ne sont jamais vides,
même si les arguments MotDePasse2 et/ou MotDePasse3 n’ont pas été passés à la procédure. Ce trai-
tement est nécessaire pour qu’aucune erreur ne soit provoquée lors de la vérification du texte saisi par
l’utilisateur.
Pour appeler le programme mot de passe, il suffit maintenant de placer l’instruction suivante à
l’endroit voulu :
Call ControleMotDePasse(NumTentatives, MotDePasse1, MotDePasse2, MotDePasse3)
Pour le tester, placez la procédure suivante dans n’importe quel module du projet et exécutez-la.
1: Sub TestControlePlusieursMotsDePasse()
2: Call ControleMotDePasse(5, "Bonjour")
3: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
4: vbOKOnly + vbInformation
5: Call ControleMotDePasse(5, "Bonjour", "Salut")
6: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
7: vbOKOnly + vbInformation
8: Call ControleMotDePasse(5, "Bonjour", "Salut", "Coucou")
9: MsgBox "Mot de passe correct." & vbCr & "Poursuite de l'exécution.", _
10: vbOKOnly + vbInformation
11: End Sub
Conseil
Le fait que des macros soient numériquement signées ne vous garantit pas leur fiabilité. Un développeur
malhonnête peut se procurer une signature électronique pour signer des virus macros. Ne vous fiez aux
signatures électroniques que si elles authentifient une personne ou une société de votre connaissance.
Info
Si la commande Certificat numérique n’apparaît pas dans le groupe Microsoft Office, recherchez le fichier
Selfcert.exe.
Notions avancées de la programmation Excel
446 Quatrième partie
Info
L’outil selfcert n’est pas installé par défaut avec Office 365.
Pour une liste exhaustive des organismes de certification, consultez l’aide en ligne d’Office ou,
dans la boîte de dialogue représentée à la figure 17-11, cliquez sur le lien.
Figure 17-12 – La boîte de dialogue Signature numérique gère les signatures affectées à vos projets.
18
Exemple complet
d’application Excel
Ce chapitre constitue un récapitulatif. Nous vous proposons d’y créer un programme complet,
étape par étape, de sa définition à son intégration dans l’interface d’Excel, qui mette en pratique
l’ensemble des connaissances acquises au cours de cet ouvrage.
Info
Si ce n’est déjà fait, téléchargez les codes sources des exemples du livre à l’adresse suivante : http://www.
editions-eyrolles.com/dl/0067786. Commencez par décompresser l’archive, puis testez le programme que
nous développerons dans ce chapitre en ouvrant le fichier chap17.xlsx du dossier Bonus.
Avant de commencer
Pour les besoins du programme, créez un fichier Word semblable à celui de la figure 18-2 et
enregistrez-le sous le nom Contrats Auteurs.doc dans le dossier C:\Mes documents\. Vous pouvez
également utiliser les fichiers fournis avec les exemples sources du livre, situés dans le dossier
Bonus.
Figure 18-2 – Chaque fois qu’un contrat est édité, les données sont intégrées dans un fichier Word.
Exemple complet d’application Excel
Chapitre 18
449
Le programme VBA que vous développerez dans ce chapitre utilise le contrôle Calendrier pour
inviter l’utilisateur à sélectionner des dates. Celui-ci n’est pas activé par défaut, commencez
par le référencer dans la boîte à outils de Visual Basic. La procédure est décrite à la section
« Personnaliser la boîte à outils » du chapitre 13.
Attention
Si vous installez vos macros sur différents ordinateurs, les contrôles personnalisés qu’elles utilisent devront
être installés sur chaque ordinateur.
Une fois le contrôle Calendrier installé sur votre ordinateur, testez le programme. Ouvrez le fichier
chap17.xls des codes sources du livre. Si Excel affiche un message d’avertissement, activez le
contenu du fichier, puis cliquez sur le bouton Editer un contrat. Suivez les étapes du programme.
Jetez maintenant un œil au dossier contenant le fichier chap17.xls : il contient les feuilles de paie
que le programme a éditées. Par ailleurs, le document Contrat auteurs.doc a été mis à jour.
Le contrat sera établi au nom d’une personne physique ou à celui d’une société. Dans le premier
cas, un prénom devra être fourni.
Info
Pour les besoins du programme, créez un fichier Excel semblable à celui de la figure 18-3 et enregistrez-le
sous le nom Classeur Auteurs.xlsx dans le dossier C:\Mes documents. Vous pouvez également utiliser les
fichiers fournis avec les exemples sources du livre, situés dans le dossier Bonus.
• Ouvrage. Titre de l’ouvrage et ISBN (International Standard Book Number, numéro iden-
tifiant l’ouvrage de façon unique).
L’ISBN sera toujours formaté de la façon suivante : xxxx-y, où chaque x correspond à un chiffre
et chaque y à une clé pouvant être un chiffre ou une lettre.
• Conditions de rémunération. Droits d’auteur et avance sur droits d’auteur.
Les droits d’auteur sont un pourcentage du prix de vente de l’ouvrage, soit fixe, soit variable
(par exemple, 6 % sur les 3 000 premiers livres, puis 8 %).
L’avance sur droits d’auteur est facultative. Dans le cas d’une avance, celle-ci pourra être
versée en une fois (à la remise du manuscrit) ou en deux fois (une moitié à la remise et une
moitié à la parution).
• Taxes. Les taxes retenues sur l’avance sur droits d’auteur sont la TVA, les AGESSA, la CSG et
le RDS. Le programme n’aura cependant pas à les traiter, puisque nous créerons un classeur
modèle dans lequel nous intégrerons les formules nécessaires.
• Dates. Date de remise et date de parution.
La date de parution devra toujours être postérieure à la date de remise. Par ailleurs, si moins
de 40 jours séparent la date de remise de la date de parution, une confirmation sera demandée
à l’utilisateur.
• Options d’impression. L’utilisateur aura le choix d’imprimer ou non les documents édités.
Il pourra également définir le nombre d’exemplaires imprimés pour le courrier et pour les
feuilles de paie.
Le squelette du programme
Le programme sera structuré de la façon suivante :
1. Déclaration des variables objets et liaison avec les fichiers à lire ou à manipuler (répertoire
des auteurs et document Word à compléter).
Exemple complet d’application Excel
Chapitre 18
451
Les modules
Créez les modules suivants pour accueillir les procédures :
• ContratAuteur. On y retrouvera les déclarations de variables, la procédure principale et les
procédures spécifiques au contrat d’auteur. Les variables devront être publiques pour être
manipulées à partir de n’importe quel module, notamment à partir des interfaces afin de leur
affecter les valeurs entrées par l’utilisateur.
• ContratsDivers. Ce module regroupera les procédures susceptibles d’être réutilisées par d’autres
programmes (par exemple un programme de contrat de traduction), telles que l’impression,
l’enregistrement, etc.
• RepertoireAuteurs. Ce module regroupera les procédures destinées à manipuler le répertoire
des auteurs. Elles devront être publiques pour être appelées à partir du module ContratAuteur
et manipulées à partir des interfaces utilisateur.
Notions avancées de la programmation Excel
452 Quatrième partie
Type Auteur
Prenom As String
Nom As String
Adresse As String
CodePostal As String
Ville As String
Pays As String
Societe As Boolean
End Type
Exemple complet d’application Excel
Chapitre 18
453
Type ConditionsAuteur
Titre As String
ISBN As String
TauxVariable As Boolean
TauxDroitsNum1 As Byte
TauxDroitsNum2 As Byte
TauxDroitsStr1 As String
TauxDroitsStr2 As String
NumExemplairesTaux1 As Integer
AvanceOuNon As Boolean
AvanceSurDroits As Integer
NumPaiements As Byte
remise As Date
Parution As Date
End Type
Type OptionsImpression
Imprimer As Boolean
ImprimerCourrier As Boolean
ImprimerPaie As Boolean
nbreCourrier As Variant
nbrePaie As Variant
End Type
Ajoutez en-dessous la déclaration des variables publiques dans lesquelles seront stockées les
données. Elles doivent se trouver dans la zone de déclaration du module (hors de toute procédure)
pour être accessibles dans tout le reste du projet.
Public MonAuteur As Auteur
Public MesConditionsAuteur As ConditionsAuteur
Public MonImpression As OptionsImpression
Public ClasseurAuteurs As Workbook
Public MonTableauWord
Les trois premières instructions déclarent les variables dans lesquelles seront stockées les infor-
mations fournies par l’utilisateur. Les deux dernières variables se verront respectivement affecter
le classeur des auteurs et le document Word contenant le tableau récapitulatif des contrats.
La figure 18-5 présente le module ContratAuteur tel qu’il doit se présenter à ce stade.
Attention
Avant de manipuler des fichiers Word, vous devez créer une référence à la bibliothèque d’objets de l’éditeur
de texte. Choisissez la commande Références du menu Outils de Visual Basic Editor et cochez la case
Microsoft Word Object Library (voir figure 18-6). Si vous omettez de le faire, l’instruction de déclaration de
la variable MonTableauWord générera une erreur.
Notions avancées de la programmation Excel
454 Quatrième partie
Figure 18-5 – Le module ContratAuteur contient les déclarations de types et le corps de la procédure principale.
Attention
Veillez à personnaliser les chemins d’accès aux fichiers utilisés dans cet exemple.
Conseil
Testez votre feuille de calcul. Entrez une valeur dans la cellule F15 et voyez si les cellules liées sont mises
à jour avec les valeurs appropriées.
Nous n’entrerons pas ici dans le détail des formules et la façon de calculer les droits d’auteur.
Notez simplement que la CSG et le RDS sont calculés sur une base de 95 % du montant brut et
que le montant net se calcule de la façon suivante :
Net = Brut + TVA – AGESSA – CSG – RDS
La « Contribution à verser » et la TVA (lignes 26 et 27) sont des taxes dues par l’éditeur.
Le tableau 18-1 présente les informations qui devront être complétées par le programme dans
la feuille de paie.
Notions avancées de la programmation Excel
456 Quatrième partie
Tableau 18-1. Définition des cellules qui devront être renseignées par le programme
Cellule Contenu
C2 Auteur (Prénom + Nom) ou Société
C3 Titre de l’ouvrage
C4 ISBN
C6 Date de remise
C7 Date de parution
C9 Adresse
C10 Code postal
C11 Ville
C12 Pays
F15 Montant de l’avance sur droits à payer
F30 Date de règlement
Exemple complet d’application Excel
Chapitre 18
457
Cellule Contenu
B32 Nombre d’exemplaires touchés par le taux 1
F32 Taux 1 sous forme de valeur numérique
F33 Taux 2 sous forme de valeur numérique
G32 Taux 1 sous forme de chaîne
G33 Taux 2 sous forme de chaîne
Feuille fmContratAuteur
La feuille fmContratAuteur contiendra une liste modifiable pour sélectionner le nom de l’auteur
parmi ceux du classeur Excel Répertoire Auteurs.xlsx. Elle contiendra également cinq zones de
texte qui indiqueront respectivement le prénom, l’adresse, le nom, le code postal, la ville et le pays.
Une case à cocher précisera s’il s’agit d’une société. Outre les boutons Suite et Annuler, un bouton
permettra d’ajouter les coordonnées d’une personne au fichier Excel des auteurs. La figure 18-8
présente la feuille fmContratAuteur en mode Conception.
Info
Afin de mettre en valeur les différentes phases d’écriture des procédures événementielles d’une feuille,
nous détaillerons les procédures de la feuille fmContratAuteur pour chaque contrôle. Pour les feuilles
suivantes, nous présenterons l’ensemble des procédures en un seul listing que nous commenterons.
Notions avancées de la programmation Excel
458 Quatrième partie
Créez la feuille fmContratAuteur en vous fondant sur la figure 18-8. Placez un Frame contenant un
ComboBox, cinq TextBox et un CheckBox. Placez un Label au-dessus de chaque TextBox et au-dessus
du ComboBox afin d’en libeller la fonction (Nom, Prénom, Adresse, Code postal, Ville, Pays). Placez
trois CommandButton hors du Frame. Affectez les propriétés suivantes aux contrôles :
Propriété Valeur
Feuille
Name fmContratAuteur
Caption Contrat auteur
Contrôle Frame
Caption Auteur :
Contrôle ComboBox
Name cboNom
Style 0 - fmStyleDropDownCombo
MatchEntry 1 - fmMatchEntryComplete
Contrôle TextBox 1
Name txtPrenom
Contrôle TextBox 2
Name txtAdresse
Contrôle TextBox 3
Name txtCodePostal
Exemple complet d’application Excel
Chapitre 18
459
Propriété Valeur
Contrôle TextBox 4
Name txtVille
Contrôle TextBox 5
Name txtPays
Contrôle Label 1
Name lbNom
Caption Nom
Contrôle Label 21
Name lbPrenom
Caption Prénom
Contrôle CheckBox
Name chkSociete
Caption Contrat au nom d’une société
Contrôle CommandButton 1
Name cmdAnnuler
Caption Annuler
Cancel True
Contrôle CommandButton 2
Name cmdAjouterAuteur
Caption Ajouter auteur
Contrôle CommandButton 3
Name cmdSuite
Caption Suite
Default True
1. Il n’est pas nécessaire de définir les propriétés Name des autres contrôles Label, car
ils ne seront pas manipulés.
La procédure d’initialisation commence par afficher un message dans la barre d’état de l’appli-
cation afin d’informer l’utilisateur du chargement en cours. Ligne 3, le curseur est transformé
en sablier. Ligne 4, MiseAjourListeDeroulante est appelée, puis la procédure appelante reprend
la main, le message de la barre d’état est effacé tandis que le curseur reprend sa forme normale.
Enfin, ligne 7, la liste modifiable reçoit le focus.
Attention
La variable ClasseurAuteurs doit avoir été déclarée et un classeur doit lui être affecté avant que la feuille
ne soit affichée. Si tel n’est pas le cas, l’instruction de la ligne 23 provoquera une erreur.
La procédure MiseAjourListeDeroulante a pour fonction d’ajouter les noms des auteurs à la liste modi-
fiable. Si celle-ci n’est pas vide, les instructions des lignes 11 à 19 suppriment d’abord les éléments
qu’elle contient. Nous y reviendrons plus tard. Lignes 20 à 26, les auteurs sont ajoutés à la liste. On
utilise pour cela une structure For…Next qui ajoute un à un le contenu des cellules de la colonne A à
la liste déroulante. Le compteur va de 2 (la cellule A2 étant la première à contenir un nom d’auteur)
au numéro de ligne de la dernière cellule non vide dans la colonne A : Range("A1").End(xlDown).Row.
Conseil
À ce stade, vérifiez que la mise à jour de la liste modifiable s’effectue correctement. Exécutez pour cela la
procédure EditionContratAuteur, après avoir pris soin d’y ajouter l’instruction d’affichage de la feuille.
Celle-ci doit se présenter comme suit :
Sub EditionContratAuteur()
Set ClasseurAuteurs = GetObject("C:\Mes documents\Classeur Auteurs.xlsx")
Set MonTableauWord = GetObject(, "Word.Application")
If Err.Number<>0 Then Err.Clear
fmContratAuteur.Show
End Sub
Exemple complet d’application Excel
Chapitre 18
461
Cette procédure événementielle met automatiquement à jour le contenu des zones de texte lorsque
l’utilisateur change le contenu de la liste modifiable Nom (par la sélection d’un nom dans la liste
ou par la saisie d’un nouveau nom). La variable LigneSel stocke le numéro de ligne du classeur
des auteurs correspondant au nom sélectionné. La propriété ListIndex du contrôle cboNom renvoie
l’index de l’élément sélectionné. On y ajoute 2 afin d’obtenir le numéro de la ligne correspondante
dans le classeur Excel – le premier nom de la liste correspond à la ligne 2 et la première valeur
d’index d’un ComboBox est 0.
Lignes 4 à 8, la valeur de chacun des TextBox est mise à jour avec les informations de la ligne
contenant le nom. Par exemple, si l’utilisateur sélectionne un nom provenant de la cellule A10,
txtPrenom reçoit le contenu de la cellule B10, txtAdresse reçoit le contenu de C10, etc.
Notez que, si l’utilisateur saisit une valeur dans le ComboBox (ce qui est possible, car la propriété
Style du contrôle a été définie à 0 - fmStyleDropDownCombo), le complément automatique apparaît si
un nom correspondant aux premières lettres saisies existe dans la liste (MatchEntry a été définie à 1
- fmMatchEntryComplete) et que les zones de texte sont automatiquement mises à jour avec les valeurs
correspondant à ce nom. Si l’utilisateur saisit un nom qui ne fait pas partie de la liste, la propriété
ListIndex du contrôle renvoie la valeur – 1. LigneSel reçoit alors la valeur 1 (– 1 + 2) et les zones de
texte affichent donc le contenu des cellules de la ligne 1, soit le titre des colonnes (voir figure 18-9).
La case à cocher Société est cochée si le contrat est établi au nom d’une personne morale. Quand
l’événement Click du contrôle est détecté, si la case est cochée (ligne 2), le Label lbNom voit
sa propriété Caption redéfinie à «Société» et les contrôles lbPrenom et txtPreNom sont masqués
Notions avancées de la programmation Excel
462 Quatrième partie
(Visible = False). Si la case est décochée, la propriété Caption de lbNom est redéfinie à «Nom» et
les contrôles lbPrenom et txtPrenom sont affichés (voir figure 18-10).
Figure 18-9 – Lorsque l’utilisateur sélectionne un nom dans la liste ou saisit un nouveau nom,
le complément automatique est proposé et les zones de texte sont mises à jour.
Figure 18-10 – Les libellés Nom et Prénom, ainsi que la zone de texte Prénom
sont affectés par l’état de la case à cocher Société.
Exemple complet d’application Excel
Chapitre 18
463
4. Code d’annulation
1: Private Sub cmdAnnuler_Click()
2: Dim rep As Byte
3: rep = MsgBox("Etes-vous sûr de vouloir annuler l'édition du contrat
➥ en cours ?", _
4: vbYesNo + vbQuestion, "Annuler l'édition de contrat ?")
5:
6: If rep=vbYes Then
7: Me.Hide
8: Call ContratFin
9: End
10: End If
11: End Sub
12:
13: Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
14: Dim rep As Byte
15: rep = MsgBox("Etes-vous sûr de vouloir annuler l'édition du contrat
➥ en cours ?", _
16: vbYesNo + vbQuestion, "Annuler l'édition de contrat ?")
17:
18: If rep=vbYes Then
19: Me.Hide
20: Call ContratFin
21: End
22: End If
23: End Sub
24:
25: Public Sub ContratFin()
26: 'Libérer les ressources mémoire occupées par la variable objet
27: Set ClasseurAuteurs = Nothing
28: 'Curseur classique
29: Application.Cursor = xlDefault
30: End Sub
La procédure cmdAnnuler_Click gère l’annulation via le bouton Annuler – déclenchée par un clic
sur le bouton ou la frappe de la touche Échap – et UserForm_QueryClose gère un clic sur la case de
fermeture de la fenêtre. Elles sont toutes deux semblables : la boîte de dialogue représentée à la
figure 18-11 s’affiche. Si l’utilisateur clique sur le bouton Oui, la procédure ContratFin est appelée
et l’instruction End met fin au programme.
Placez ContratFin dans le module ContratsDivers. Elle est déclarée publique pour que n’im-
porte quel module du projet puisse l’appeler. Elle a pour fonction de libérer la variable objet
ClasseurAuteurs et de redéfinir le curseur.
Notions avancées de la programmation Excel
464 Quatrième partie
Figure 18-12 – Le programme vérifie qu’il n’existe pas déjà une entrée pour l’auteur.
Si aucune entrée semblable n’a été trouvée, le programme atteint la ligne 25 sans que rien ne
se soit passé. Le nouvel auteur est alors ajouté sans qu’une intervention de l’utilisateur ne soit
requise : CreerEntreeAuteur est appelée ligne 31, puis la procédure appelante reprend la main
et le classeur est trié et sauvegardé (lignes 34 et 35). La liste modifiable est ensuite mise à jour
(ligne 39). Notez que la procédure MiseAjourListeDeroulante commence par supprimer les entrées
Exemple complet d’application Excel
Chapitre 18
467
de la liste pour les ajouter à nouveau. Enfin, lignes 40 et 41, la barre d’état et le curseur retrouvent
leur aspect par défaut.
CreerEntreeAuteur et RemplacerEntreeAuteur reçoivent toutes les deux les nom, prénom, adresse,
code postal, ville et pays entrés par l’utilisateur dans l’interface. RemplacerEntreeAuteur reçoit
en plus le numéro de la ligne à remplacer (notez les appels, lignes 18 et 31, et les déclara-
tions, lignes 45 et 59). Tandis que CreerEntreeAuteur ajoute les informations sur une ligne vide,
RemplacerEntreeAuteur remplace les données de la ligne dont le numéro lui a été passé par celles
fournies par l’utilisateur.
La procédure CmdSuite_Click vérifie la validité des informations fournies par l’utilisateur et affecte
ces valeurs aux variables appropriées. Lignes 3 à 30, une instruction conditionnelle est utilisée
pour vérifier que chaque zone de texte a été complétée. Si tel n’est pas le cas, un message s’affiche
à l’attention de l’utilisateur (voir figure 18-13), le focus est passé au contrôle non renseigné et une
instruction Exit entraîne la sortie de la procédure. Notez l’expression conditionnelle de la ligne 9
qui vérifie si le prénom n’est pas fourni ET si la case Société n’est pas cochée.
Figure 18-13 – Les données sont vérifiées avant d’être affectées aux variables.
Si les données fournies sont valides, la structure With…End With des lignes 33 à 43 affecte les valeurs
fournies aux espaces de stockage appropriés de la variable publique MonAuteur. Notez que, si le
champ Pays n’est pas renseigné (s’il s’agit de la France), l’espace MonAuteur.Pays ne reçoit pas de
valeur ; dans le cas contraire, il reçoit la valeur fournie précédée d’un retour chariot. Vous verrez
plus tard pourquoi. Ligne 44, la feuille est masquée.
Feuille fmContratConditions
La feuille fmContratConditions contiendra, un contrôle Frame libellé Ouvrage et un autre libellé
Conditions de rémunération. Le premier contiendra deux Label identifiant deux zones de texte
destinées à entrer le nom de l’ouvrage et son ISBN. Le deuxième contiendra deux autres cadres,
Exemple complet d’application Excel
Chapitre 18
469
l’un libellé Droits d’auteur et l’autre libellé Avance. Le cadre Droits d’auteur contiendra les
contrôles précisant si le taux est variable (CheckBox), le taux initial (TextBox, Label et SpinButton),
l’éventuel deuxième taux (TextBox, Label et SpinButton) et au-delà de combien d’exemplaires celui-
ci s’applique (TextBox et deux Label). Le cadre Avance indiquera s’il y a ou non une avance sur
droits d’auteur (CheckBox) et, dans l’affirmative, la valeur de cette avance (TextBox et deux Label)
et le nombre de versements (deux OptionButton). Outre les boutons Annuler et Suite, un bouton
Retour permettra de revenir à la feuille précédente.
Créez la feuille fmContratConditions en vous fondant sur les figures 18-14 et 18-15, ainsi que sur
le tableau suivant.
spinTaux1 lbVar1
lbLabel
chkTauxVariable
txtTaux1 txtNumEx
txtTaux2
lbVar3
spinTaux2 lbVar2
Propriété Valeur
Feuille
Name fmContratConditions
Caption Contrat d’auteur
Contrôle Frame 1
Caption Ouvrage
Contrôle Frame 2
Caption Conditions de rémunération
Contrôle Frame 2.1
Caption Droits d’auteur
Contrôle Frame 2.2
Caption Avance
Cont rôle s du Frame 1
Contrôle TextBox 1
Name txtTitre
Contrôle TextBox 2
Name txtISBN
Contrôle Label 1
Caption Titre de l’ouvrage
Contrôle Label 2
Caption ISBN
Cont rôle s du Frame 2.1
Contrôle CheckBox
Name chkTauxVariable
Caption Taux variable
Value False
Contrôle TextBox 1
Name txtTaux1
Value 8
Contrôle TextBox 2
Name txtTaux2
Value 8
Contrôle TextBox 3
Name txtNumEx
Value 4000
Enabled False
Contrôle SpinButton 1
Name spinTaux1
Value 8
Min 1
Max 20
Exemple complet d’application Excel
Chapitre 18
471
Propriété Valeur
Contrôle SpinButton 2
Name spinTaux2
Value 8
Min 1
Max 20
Enabled False
Contrôle Label 1
Name Label1
Caption % du prix public HT
Enabled True
Contrôle Label 2
Name lbVar1
Caption sur
Enabled False
Contrôle Label 3
Name lbVar2
Caption sur
Enabled False
Contrôle Label 4
Name lbVar3
Caption % du prix HT sur les ex. suivants
Enabled False
Cont rôle s du Frame 2.2
Contrôle CheckBox
Name chkAvance
Caption Avances sur droits d’auteur
Value True
Contrôle TextBox 1
Name txtAvance
Value 1000
Contrôle Label 1
Name lbAvance1
Caption de
Contrôle Label 2
Name lbAvance2
Caption euros
Contrôle OptionButton 1
Name optUnVersement
Caption Un versement (parution)
Value False
Notions avancées de la programmation Excel
472 Quatrième partie
Propriété Valeur
Contrôle OptionButton 2
Name optDeuxVersements
Caption Deux versements (parution et remise)
Value True
Bout ons de c om m a nde
Contrôle CommandButton 1
Name cmdAnnuler
Caption Annuler
Cancel True
Contrôle CommandButton 2
Name cmdRetour
Caption Retour
Contrôle CommandButton 3
Name CmdSuite
Caption Suite
Default True
27: txtTaux1.Value = ""
28: txtTaux1.SetFocus
29: Exit Sub
30: ElseIf txtTaux1.Value<1 Or txtTaux1.Value>20 Then
31: MsgBox "Le taux pour les droits d'auteur doit être compris entre 1
➥ et 20.", _
32: vbOKOnly + vbInformation, "Valeur non valide"
33: txtTaux1.Value = ""
34: txtTaux1.SetFocus
35: End If
36: spinTaux1.Value = txtTaux1.Value
37: End Sub
38:
39: Private Sub txtTaux2_Change()
40: If IsNumeric(txtTaux2.Value)=False Then
41: MsgBox "Le taux pour les droits d'auteur doit être une valeur
➥ numérique.", _
42: vbOKOnly + vbInformation, "Informations incomplètes"
43: txtTaux2.Value = ""
44: txtTaux2.SetFocus
45: Exit Sub
46: ElseIf txtTaux2.Value<1 Or txtTaux2.Value>20 Then
47: MsgBox "Le taux pour les droits d'auteur doit être compris entre 1
➥ et 20.", _
48: vbOKOnly + vbInformation, "Valeur non valide"
49: txtTaux2.Value = ""
50: txtTaux2.SetFocus
51: Exit Sub
52: spinTaux2.Value = txtTaux1.Value
53: End If
54: End Sub
55:
56: Private Sub spinTaux1_Change()
57: txtTaux1.Value = spinTaux1.Value
58: End Sub
59:
60: Private Sub spinTaux2_Change()
61: txtTaux2.Value = spinTaux2.Value
62: End Sub
63:
64: Private Sub chkAvance_Click()
65: If chkAvance.Value=True Then
66: lbAvance1.Visible = True
67: lbAvance2.Visible = True
68: txtAvance.Visible = True
69: optUnVersement.Enabled = True
70: optDeuxVersements.Enabled = True
71: Else
72: lbAvance1.Visible = False
73: lbAvance2.Visible = False
Notions avancées de la programmation Excel
474 Quatrième partie
122: Exit Sub
123: End If
124: If Len(txtISBN.Value)<>6 Then
125: MsgBox "L'ISBN n'est pas correctement formaté.", _
126: vbOKOnly + vbInformation, "Informations incomplètes"
127: txtISBN.SetFocus
128: Exit Sub
129: End If
130:
131: If txtTaux1.Value="" Then
132: MsgBox "Vous devez indiquer un taux pour les droits d'auteur.", _
133: vbOKOnly + vbInformation, "Informations incomplètes"
134: txtTaux1.SetFocus
135: Exit Sub
136: End If
137:
138: If txtTaux2.Value="" And chkTauxVariable=True Then
139: MsgBox "Vous devez indiquer un taux pour les droits d'auteur.", _
140: vbOKOnly + vbInformation, "Informations incomplètes"
141: txtTaux2.SetFocus
142: Exit Sub
143: End If
144:
145: If txtNumEx.Value="" And chkTauxVariable=True Then
146: MsgBox "Vous devez indiquer une valeur valide pour le nombre d'exemplaires
➥ affectés par le taux 1.", _
147: vbOKOnly + vbInformation, "Informations incomplètes"
148: txtNumEx.SetFocus
149: Exit Sub
150: End If
151: If IsNumeric(txtNumEx.Value)=False And chkTauxVariable=True Then
152: MsgBox "Le nombre d'exemplaires concernés par le taux doit être une valeur
➥ numérique.", _
153: vbOKOnly + vbInformation, "Informations incomplètes"
154: txtNumEx.Value = ""
155: txtNumEx.SetFocus
156: Exit Sub
157: End If
158:
159: If txtAvance.Value="" And chkAvance=True Then
160: MsgBox "Vous devez indiquer une somme pour l'avance sur droits
➥ d'auteur.", _
161: vbOKOnly + vbInformation, "Informations incomplètes"
162: txtAvance.SetFocus
163: Exit Sub
164: End If
165: If IsNumeric(txtAvance.Value)=False And chkAvance=True Then
166: MsgBox "L'avance sur droits d'auteur doit être une valeur numérique.", _
167: vbOKOnly + vbInformation, "Informations incomplètes"
168: txtAvance.Value = ""
Notions avancées de la programmation Excel
476 Quatrième partie
169: txtAvance.SetFocus
170: Exit Sub
171: End If
172:
173: 'Validation des données
174: With MesConditionsAuteur
175: .Titre = txtTitre.Value
176: .ISBN = txtISBN.Value
177: .TauxVariable = chkTauxVariable.Value
178: .TauxDroitsNum1 =txtTaux1.Value
179: .TauxDroitsNum2 = txtTaux2.Value
180: .NumExemplairesTaux1 = txtNumEx.Value
181: .AvanceOuNon = chkAvance.Value
182: If MesConditionsAuteur.AvanceOuNon=True Then
183: MesConditionsAuteur.AvanceSurDroits = txtAvance.Value
184: End If
185: If optUnVersement=True Then
186: MesConditionsAuteur.NumPaiements = 1
187: Else
188: MesConditionsAuteur.NumPaiements = 2
189: End If
190: 'Obtention des équivalents chaînes des valeurs
191: MesConditionsAuteur.TauxDroitsStr1 = RenvoyerChaîneValeur(.TauxDroitsNum1)
192: MesConditionsAuteur.TauxDroitsStr2 = RenvoyerChaîneValeur(.TauxDroitsNum2)
193: End With
194:
195: Me.Hide
196: End Sub
La procédure d’initialisation (lignes 1 à 3) a pour seule fonction de passer le focus au contrôle
txtTitre.
La procédure chkTauxVariable_Click (lignes 5 à 21) gère l’événement clic survenant sur la case
à cocher Taux variable. Si cette dernière est cochée, les trois libellés txtVar1, txtVar2 et txtVar3
deviennent disponibles. Il en est de même pour la zone de texte txtTaux2 et le bouton toupie qui
lui est attaché (spinTaux2), ainsi que pour la zone de texte txtNumEx (lignes 7 à 12). Si la case est
décochée, tous ces contrôles sont désactivés (voir figure 18-16).
Les procédures txtTaux1_Change et txtTaux2_Change (lignes 23 à 54) gèrent de façon identique
les modifications apportées aux zones de texte destinées à recevoir les droits d’auteur. Lignes 24
à 29 et 40 à 45, on vérifie que la valeur entrée est un nombre. Dans le cas contraire, un message
s’affiche à l’attention de l’utilisateur, la valeur du contrôle est réinitialisée et le focus lui est passé.
Une instruction Exit entraîne la sortie de la procédure. Lignes 30 à 34 et 46 à 51, un traitement
similaire est appliqué si la valeur saisie n’est pas comprise entre 1 et 20. Enfin, si la valeur entrée
est valide, les instructions des lignes 36 et 52 l’affectent au bouton toupie associé.
Exemple complet d’application Excel
Chapitre 18
477
Les procédures des lignes 56 à 62 affectent la valeur des boutons toupies aux zones de texte
associées lorsque l’utilisateur clique sur l’un d’eux.
La procédure chkAvance_Click (lignes 64 à 78) gère les clics sur la case à cocher Avance sur droits
d’auteur. Si cette dernière est cochée, les libellés lbAvance1 et lbAvance2 sont visibles (lignes 66
et 67). Il en est de même pour la zone de texte txtAvance. Enfin, les deux boutons d’option
deviennent accessibles (lignes 69 et 70). Si la case est décochée, le traitement inverse est appliqué
à ces contrôles (voir figure 18-18).
Notions avancées de la programmation Excel
478 Quatrième partie
Figure 18-18 – L’état de la case à cocher Avance sur droits d’auteur influe
sur les propriétés des autres contrôles du cadre.
Lignes 191 et 192, RenvoyerChaîne est appelée à deux reprises pour retourner les deux valeurs de
taux sous forme de chaînes de caractères, pour les besoins du contrat. Placez cette fonction dans
le module ContratsDivers. Elle se présente comme suit :
Public Function RenvoyerChaîneValeur(valeur)
Select Case valeur
Case 0
RenvoyerChaîneValeur = "zéro"
Case 1
RenvoyerChaîneValeur = "un"
Case 2
RenvoyerChaîneValeur = "deux"
Case 3
RenvoyerChaîneValeur = "trois"
...
Case 19
RenvoyerChaîneValeur = "dix-neuf"
Case 20
RenvoyerChaîneValeur = "vingt"
End Select
End Function
Notions avancées de la programmation Excel
480 Quatrième partie
Conseil
À ce stade, placez l’instruction d’affichage de la feuille fmContratConditions dans la procédure Edi-
tionContratAuteur et exécutez cette dernière afin de vérifier que votre programme ne contient pas d’er-
reurs. Testez les différentes conditions en entrant des données variables dans les interfaces. EditionCon-
tratAuteur doit maintenant se présenter comme suit :
Sub EditionContratAuteur()
Set ClasseurAuteurs = GetObject("C:\Mes documents\Classeur Auteurs.xlsx")
Set MonTableauWord = GetObject(, "Word.Application")
If Err.Number<>0 Then Err.Clear
fmContratAuteur.Show
fmContratConditions.Show
End Sub
Feuille fmContratDates
La feuille fmContratDates demandera à l’utilisateur d’indiquer les dates de remise et de parution.
Nous utiliserons pour cela le contrôle Calendar. Une liste modifiable permettra de sélectionner
ce que l’utilisateur veut préciser : date de remise ou date de parution. Deux zones de texte dont la
fonction sera précisée par deux Label montreront les dates sélectionnées sur le calendrier, mais
leur valeur ne pourra être modifiée. Enfin, nous retrouverons les mêmes boutons de commande
que pour la feuille fmContratConditions, à savoir Annuler, Retour et Suite (figure 18-20).
Calendar ne fait pas partie des contrôles standards de la boîte à outils Visual Basic Editor et n’est
pas livré avec toutes les versions d’Excel. Nous l’avons joint aux codes sources des exemples
du livre. Commencez par ajouter ce contrôle ; la procédure à suivre est décrite dans la section
« Personnaliser la boîte à outils » du chapitre 13.
Pour « dessiner » la feuille fmContratDates, commencez par placer un Frame contenant deux TextBox
et un ComboBox. Déposez trois Label à côté de chacun d’eux afin d’en préciser la fonction. Déposez et
dimensionnez le contrôle Calendar. Déposez à l’extérieur du cadre les trois boutons de commande.
Astuce
Copiez les boutons de la feuille fmContratConditions et collez-les sur fmContratDates. Ainsi vous
n’aurez pas à en redéfinir les propriétés. Vous pouvez également copier-coller les procédures cmdAnnu-
ler_Click et UserForm_QueryClose puisqu’elles sont identiques d’une feuille à l’autre.
Définissez les propriétés des contrôles comme indiqué dans le tableau suivant :
Propriété Valeur
Feuille
Name fmContratDates
Caption Dates de remise et de parution
Contrôle Frame
Caption Indiquez la date à valider et sélectionnez-la sur le calendrier
Contrôle TextBox 1
Name txtRemise
Enabled False
Contrôle TextBox 2
Name txtParution
Enabled False
Contrôle ComboBox
Name cboDateAValider
Style 2 - fmStyleDropDownList
Contrôle Label 1
Caption Date de remise :
Contrôle Label 2
Caption Date de parution :
Contrôle Label 3
Caption Date à valider :
Contrôle Calendar
Name Calendrier
Notions avancées de la programmation Excel
482 Quatrième partie
Propriété Valeur
Contrôle CommandButton 1
Name cmdAnnuler
Caption Annuler
Cancel True
Contrôle CommandButton 2
Name cmdRetour
Caption Retour
Contrôle CommandButton 3
Name cmdSuite
Caption Suite
Default True
Ouvrez ensuite la fenêtre Code de la feuille et placez-y les procédures événementielles reproduites
ci-après :
1: Private Sub UserForm_Initialize()
2: cboDateAValider.AddItem ("Date de remise")
3: cboDateAValider.AddItem ("Date de parution")
4: cboDateAValider.ListIndex = 0
5: Calendrier.Value = Date + 30
6: Calendrier.SetFocus
7: End Sub
8:
9: Private Sub Calendrier_Click()
10: If cboDateAValider.ListIndex=0 Then
11: txtRemise.Value = Calendrier.Value
12: cboDateAValider.ListIndex = 1
13: Else
14: TxtParution.Value = Calendrier.Value
15: End If
16: End Sub
17:
18: Private Sub CmdAnnuler_Click()
... Mêmes instructions que pour la feuille fmContratConditions
28: End Sub
29:
30: Private Sub UserForm_QueryClose(Cancel As Integer, CloseMode As Integer)
... Mêmes instructions que pour la feuille fmContratConditions
40: End Sub
41:
42: Private Sub cmdRetour_Click()
43: fmContratConditions.Show
44: End Sub
45:
Exemple complet d’application Excel
Chapitre 18
483
La procédure d’initialisation (lignes 1 à 7) ajoute les entrées Date de remise et Date de parution
à la liste modifiable (lignes 2 et 3), puis active le premier élément de la liste (ligne 4). Ligne 5
et 6, la valeur du calendrier est définie à 30 jours de la date courante – renvoyée par la fonction
Date – et le calendrier reçoit le focus.
Calendrier_Click (lignes 9 à 16) gère l’affectation des dates aux zones de texte txtRemise et
txtParution. Une structure conditionnelle est utilisée pour définir l’entrée choisie dans la liste
modifiable et écrire la date retenue dans la zone de texte correspondante (lignes 11 et 14). Si le
premier élément de la liste est sélectionné (Date de remise), txtRemise reçoit la valeur, puis le
second élément est sélectionné (ligne 12), ce qui permet à l’utilisateur de choisir immédiatement
la date de parution.
cmdRetour_Click (lignes 42 à 44) gère les clics sur le bouton Retour. Elle affiche la feuille
fmContratConditions.
Notions avancées de la programmation Excel
484 Quatrième partie
Enfin, cmdSuite_Click (lignes 46 à 75) vérifie la validité des dates indiquées (lignes 48 à 68) et
affecte ces valeurs aux variables appropriées. Une seule instruction conditionnelle est utilisée.
Lignes 49 à 56, on vérifie que les deux dates ont été précisées. Si tel n’est pas le cas, un message
s’affiche à l’attention de l’utilisateur et une instruction Exit entraîne la sortie de la procédure
(voir figure 18-21).
Lignes 57 à 60, on vérifie que la date de parution est postérieure à celle de remise, grâce à la
fonction DateValue qui renvoie la valeur de la date sous forme numérique (consultez l’aide en ligne
pour plus de précisions). Si tel n’est pas le cas, un message s’affiche à l’attention de l’utilisateur et
une instruction Exit entraîne la sortie de la procédure. Lignes 61 à 68, on vérifie si plus de 40 jours
séparent les deux dates. Si tel n’est pas le cas, l’utilisateur en est averti par un message. Il peut alors
valider les dates ou cliquer sur le bouton Non, ce qui entraîne la sortie de la procédure (ligne 67).
Ligne 70, la feuille est masquée. Les dates fournies sont ensuite affectées aux espaces de stockage
appropriés de la variable MesConditionsAuteur.
Conseil
Placez l’instruction d’affichage de la feuille fmContratDates dans la procédure EditionContratAuteur et
exécutez cette dernière afin de vérifier que votre programme ne contient pas d’erreurs. EditionContratAu-
teur doit maintenant se présenter comme suit :
Sub EditionContratAuteur()
Set ClasseurAuteurs = GetObject("C:\Mes documents\Classeur Auteurs.xlsx")
Set MonTableauWord = GetObject(, "Word.Application")
If Err.Number<>0 Then Err.Clear
fmContratAuteur.Show
fmContratConditions.Show
fmContratDates.Show
End Sub
Feuille fmContratImpression
Sur la feuille fmContratImpression (figure 18-23), une case à cocher demandera à l’utilisateur s’il
souhaite imprimer. Si oui, deux autres cases à cocher s’afficheront pour qu’il indique si les feuilles
de paie, le contrat ou les deux doivent être imprimés. Une zone de texte et un bouton toupie servi-
ront à préciser le nombre de copies souhaitées pour chaque impression. Enfin, nous retrouverons
les trois boutons de retour, d’annulation et de validation des feuilles précédemment créées.
Astuce
Notez l’image de l’imprimante apparaissant entre la première case à cocher et son libellé. Il s’agit d’un
contrôle Picture qui a été placé sur le CheckBox. Nous avons ajouté des espaces devant le texte de la
propriété Caption de ce dernier afin de ne pas masquer le libellé de la case à cocher.
Commencez par placer un contrôle Frame sur la feuille, dans lequel vous ajouterez trois CheckBox
(en plaçant les deux derniers en retrait par rapport au premier), puis un TextBox, un SpinButton et
un Label à côté de chaque case à cocher. Enfin, placez trois boutons de commande hors du cadre.
Définissez les propriétés des contrôles comme indiqué dans le tableau suivant.
Propriété Valeur
Feuille
Name fmContratImpression
Caption Impression du contrat
Contrôle Frame
Caption Options d’impression
Contrôle CheckBox 1
Name chkImprimer
Caption Imprimer les contrats
Value True
Contrôle CheckBox 2
Name chkImpressionContrat
Caption Contrat auteur en
Value True
Contrôle CheckBox 3
Name chkImpressionPaie
Caption Fiches de paie en
Value True
Contrôle TextBox 1
Name txtQteContrat
Value 2
Contrôle TextBox 2
Name txtQtePaie
Value 1
Contrôle SpinButton 1
Name spinContrat
Value 2
Min 1
Max 10
Exemple complet d’application Excel
Chapitre 18
487
Propriété Valeur
Contrôle SpinButton 2
Name spinPaie
Value 1
Min 1
Max 10
Contrôles Label 1 et 2
Caption Exemplaire(s)
Contrôle CommandButton 1
Name cmdAnnuler
Caption Annuler
Cancel True
Contrôle CommandButton 2
Name cmdRetour
Caption Retour
Contrôle CommandButton 3
Name cmdTerminer
Caption Terminer
Default True
La procédure d’initialisation de la feuille (lignes 1 à 8) utilise une structure conditionnelle pour
désactiver les contrôles dédiés à l’impression des feuilles de paie, si le contrat est édité au nom
d’une société – les sociétés facturent tandis qu’on établit une feuille de paie au nom des personnes
physiques. On teste pour cela la variable MonAuteur.Societe qui a reçu la valeur True ou False
lorsque l’utilisateur a validé la feuille fmContratAuteur. Si la valeur est True, chkImpressionPaie
est décochée (ligne 3), puis rendue inaccessible (ligne 4). La zone de texte et le bouton toupie
associés sont également rendus inaccessibles (lignes 5 et 6).
Notions avancées de la programmation Excel
490 Quatrième partie
chkImprimer_Click modifie l’état des contrôles définissant les éléments à imprimer et le nombre de
copies à réaliser. Si le bouton est décoché, les deux autres cases sont désactivées (lignes 12 et 13),
les deux zones de texte correspondantes sont verrouillées (lignes 14 et 15) et les deux boutons
toupies associés à ces dernières rendus inaccessibles (lignes 16 et 17). Dans le cas contraire, les
instructions des lignes 19 à 29 s’exécutent. Lignes 19 à 24, une structure conditionnelle imbriquée
active les contrôles définissant le nombre d’impression des feuilles de paie, si le contrat n’est pas
établi au nom d’une société. Les contrôles servant à définir l’impression du contrat sont activés
(lignes 25 à 28).
Lignes 32 à 40, chkImpressionContrat_Click active ou désactive l’accès à la zone de texte et au
bouton toupie correspondant à l’impression du contrat. Lignes 42 à 50, chkImpressionPaie_Click
effectue les mêmes opérations pour la case à cocher libellée Fiches de paie.
Les deux procédures des lignes 52 à 58 affectent la valeur du bouton toupie à la case correspon-
dante lorsque l’utilisateur clique sur l’un des contrôles spinContrat ou spinPaie.
Lignes 60 à 75 et lignes 77 à 92, les procédures txtQteContrat_Change et txtQtePaie_Change sont
identiques aux procédures txtTaux1_Change et txtTaux2_Change de la feuille fmContratConditions.
Elles valident les valeurs saisies dans les zones de texte et les affectent aux contrôles SpinButton
correspondants.
La procédure cmdRetour_Click (lignes 114 à 116) affiche la feuille fmContratDates.
Enfin, cmdSuite_Click (lignes 118 à 127) transfère les informations fournies dans la variable
MonImpression.
Feuille fmContratFin
La feuille fmContratFin est très simple. Elle indique à l’utilisateur que les informations nécessaires
ont été fournies et que le contrat va être édité. Elle contient un seul bouton et un contrôle Label.
Réalisez cette feuille en vous appuyant sur sa représentation de la figure 18-24 (nous avons affecté
une image bitmap à la propriété Picture du contrôle). Définissez la propriété Caption du bouton
de commande à cmdOK.
Placez maintenant les instructions suivantes dans la fenêtre Code de la feuille fmContratFin :
Private Sub cmdOK_Click()
Me.Hide
End Sub
Sub EditionContratAuteur()
'1. Liaisons des variables objets
Set ClasseurAuteurs = GetObject("C:\Mes documents\Classeur Auteurs.xlsx")
Set MonTableauWord = GetObject(, "Word.Application")
If Err.Number<>0 Then Err.Clear
22: .Range("F15").Value = _
23: MesConditionsAuteur.AvanceSurDroits / MesConditionsAuteur.NumPaiements
24:
25: If MesConditionsAuteur.NumPaiements=1 Then
26: .Range("F30").Value = MesConditionsAuteur.Parution
27: Else
28: If feuillnum=1 Then
29: .Range("F30").Value = MesConditionsAuteur.remise
30: Else
31: .Range("F30").Value = MesConditionsAuteur.Parution
32: End If
33: End If
34: If MesConditionsAuteur.TauxVariable=True Then
35: .Range("B32") = "Pour les " & _
36: MesConditionsAuteur.NumExemplairesTaux1 & _
37: " premiers ouvrages"
38: .Range("B33") = "Au-delà"
39: .Range("F32") = MesConditionsAuteur.TauxDroitsNum1 & " %"
40: .Range("G32") = MesConditionsAuteur.TauxDroitsStr1 & " pour cent"
41: .Range("F33") = MesConditionsAuteur.TauxDroitsNum2 & " %"
42: .Range("G33") = MesConditionsAuteur.TauxDroitsStr2 & " pour cent"
43: Else
44: .Range("B32") = ""
45: .Range("B33") = ""
46: .Range("F32") = MesConditionsAuteur.TauxDroitsNum1 & " %"
47: .Range("G32") = MesConditionsAuteur.TauxDroitsStr1 & " pour cent"
48: .Range("F33") = ""
49: .Range("G33") = ""
50: End If
51: End With
52: Application.Calculate
53:
54: 'impression du classeur
55: If MonImpression.Imprimer=True And MonImpression.ImprimerPaie=True
➥ Then_
56: ActiveWorkbook.PrintOut copies:=MonImpression.nbrePaie
57: End If
58:
59: 'enregistrement du classeur
60: ActiveWorkbook.SaveAs Filename:="C:\Mes Documents\" & _
61: MesConditionsAuteur.ISBN & " " & MonAuteur.Nom & " " & _
62: "Paie" & feuillnum & ".xlsx", FileFormat:=xlNormal
63: ActiveWorkbook.Close
64: Next feuillnum
65: End Sub
Notions avancées de la programmation Excel
494 Quatrième partie
Cette procédure utilise une boucle For…Next pour éditer le nombre de feuilles de paie approprié,
soit MesConditionsAuteur.NumPaiements.
À chaque passage de la boucle, un classeur fondé sur le modèle PAIEMENT.xlt est créé (ligne 6).
Penser à adapter le chemin apparaissant dans ce listing, qui est celui du dossier de stockage
des modèles. Lignes 7 à 34, une structure With…End With est utilisée pour insérer les données
appropriées dans les cellules du classeur. Ligne 22, l’avance sur droits d’auteur est divisée par
le nombre de paiements. Lignes 25 à 33, une structure conditionnelle sert à définir les dates de
règlement : si un seul paiement est effectué, le règlement s’opère à la parution (ligne 26), si deux
versements sont demandés (lignes 27 à 33), le premier est versé lors de la remise (ligne 29) et le
second lors de la parution (ligne 31). Lignes 35 à 50, une structure conditionnelle complète les
informations concernant les taux des droits d’auteur. Ligne 52, le calcul est forcé. Lignes 55 à 57,
le classeur est imprimé. Les lignes 60 à 62 correspondent à une seule instruction d’enregistrement.
Le classeur est enregistré dans le dossier C:\Mes documents et a pour nom ISBN Nom Paie1.xlsx
ou ISBN Nom Paie2.xlsx. Ligne 63, le classeur est fermé.
Ligne 3, la variable MonTableauWord se voit affecter un document Word. Lignes 4 et 5, une ligne
est ajoutée au premier tableau de ce document et son numéro est stocké dans la variable DerLigne.
Lignes 6 à 21, une structure With…End With complète les cellules du tableau avec les valeurs appro-
priées. Lignes 22 et 23, le tableau est enregistré puis fermé.
Telle qu’elle se présente, cette application fonctionne. Pour la sécuriser, vous devez cependant la
tester dans des conditions différentes et mettre en place des gestionnaires d’erreur. De multiples
conditions peuvent causer une erreur. Ce sera par exemple le cas si un document utilisé (le modèle
PAIEMENT.xlt ou le document Contrats Auteur.doc par exemple) n’est pas disponible, ou est en
cours d’utilisation par un autre utilisateur.
Annexe A
Mots-clés pour la manipulation
de fichiers et de dossiers
Cette annexe présente les mots-clés dédiés à la gestion de fichiers et de dossiers. Manipulez-les
avec prudence afin de ne pas supprimer malencontreusement des données importantes !
Pour activer un modèle complémentaire à chaque lancement d’Excel, il faut le placer dans le
dossier C:\Users\Nom_utilisateur\AppData\Roaming\Microsoft\Excel\XLSTART. Ce n’est en
effet qu’en mettant ce modèle dans le dossier XLSTART qu’il sera chargé systématiquement au
lancement d’Excel.
Pour distribuer vos programmes Excel, en les proposant par exemple en téléchargement sur un
site Internet, l’opération peut toutefois être décourageante. Comme le dossier AppData est mas-
qué par défaut, l’utilisateur devra modifier les options d’affichage de Windows pour accéder au
dossier XLSTART via une fenêtre de l’explorateur. Complexe et décourageant ! Demander aux
utilisateurs d’effectuer cette opération est peu professionnel et la plupart renonceront sans doute
à la faire. Pour éviter cet écueil, concevez plutôt un programme d’installation qui sera bien plus
convaincant et rassurant pour l’utilisateur.
Voyons maintenant comment créer un programme d’installation avec Inno Setup.
Pour des informations détaillées sur Inno Setup, consultez son site Internet officiel (en anglais)
à l’adresse : http://www.jrsoftware.org. L’aide en ligne est disponible à l’adresse http://www.jrsoftware.
org/ishelp.
Quoique gratuit, ce logiciel n’en est pas moins performant et de très bonne qualité. Il permet
notamment de créer des programmes d’installation dans différentes langues, pour une distribution
de vos compléments à l’international, ou encore d’écrire dans la base de registre de Windows – par
exemple pour enregistrer la date d’installation de votre complément afin de proposer une période
d’évaluation gratuite. Lorsque votre complément est installé par Inno Setup, il apparaît dans la
liste des applications Windows et un programme de désinstallation est créé.
Nous allons ici créer un programme d’installation pour le modèle complémentaire Audit.xlsm
développé au chapitre 12.
3. Sélectionnez l’option Create a new script file using the Script Wizard, puis cliquez sur OK.
La page de bienvenue de l’assistant de création de script s’affiche (figure B-2).
4. Cliquez sur OK. Dans la fenêtre Application Information qui apparaît (figure B-3), complétez
les différents champs :
– Application name : entrez ici le nom de votre modèle complémentaire – dans notre exemple :
« Audit société JRI » ;
– Application version : le numéro de la version du logiciel – ici 1.0 ;
– Application publisher (facultatif) : votre nom ou le nom de société sous lequel vous souhaitez
distribuer votre logiciel – dans notre exemple : « Excel development company » ;
– Application website (facultatif) : l’adresse du site web associé à votre modèle complémen-
taire – dans notre exemple : « www.articho.eu ».
5. Cliquez sur Next, puis complétez les champs de la fenêtre Application Folder (figure B-4) :
– Application destination base folder : choisissez Custom et, dans la zone de texte associée,
saisissez {appdata}\Microsoft\Excel\XLSTARTUP ;
– dans la zone Application folder name, saisissez XLSTART et décochez la case Allow user to
change the application folder.
6. Cliquez sur Next, puis complétez la fenêtre Application Files (figure B-5) comme suit :
– Application main exécutable file : ignorez cette option et cochez la case The application
doesn’t have a main executable file ;
– cochez le bouton Add files, puis localisez le dossier Install créé à l’étape 1. Sélectionnez
le modèle complémentaire chap11.xlam et validez.
Créer un programme d’installation pour vos applications Excel avec Inno Setup
Annexe B
503
7. Cliquez sur Next et décochez toutes les cases de la fenêtre Application Shortcuts (figure B-6).
Programmation Excel avec VBA
504
8. Cliquez sur Next et, dans la fenêtre Application Documentation qui s’affiche (figure B-7),
utilisez, si vous le souhaitez, les boutons Browse pour identifier les fichiers au format texte
suivants :
– Licence file : il s’agit du texte de licence que l’utilisateur devra valider lors de l’installation.
Sélectionnez le fichier licence.txt ;
– Information file shown before installation : il s’agit du texte qui sera affiché au lancement
de l’installation. Sélectionnez le fichier before.txt ;
– Information file shown after installation : il s’agit du texte qui sera affiché à la fin de l’ins-
tallation. Sélectionnez le fichier after.txt.
9. Cliquez sur Next. Dans la fenêtre Setup Languages (figure B-8), sélectionnez la ou les langue(s)
de votre programme d’installation. Dans notre cas, sélectionnez English et French.
10. Cliquez sur Next et complétez les informations de la fenêtre Compiler Settings (figure B-9) :
– Custom compiler output folder : sélectionnez le dossier où sera créé le fichier du programme
d’installation. Dans notre cas, sélectionnez le dossier créé à l’étape 1 ;
– Compiler output base file name : il s’agit du nom du programme d’installation. Saisissez
« setup_audit » ;
– Custom setup icon file (facultatif) : il s’agit de l’image qui sera affectée au programme
d’installation et affichée dans les différentes fenêtres du processus d’installation. L’image
doit être au format .ico. Dans notre cas, sélectionnez le fichier logo-excel.ico.
Créer un programme d’installation pour vos applications Excel avec Inno Setup
Annexe B
505
Figure B-7 – Les trois champs de la fenêtre Application Documentation sont facultatifs.
Figure B-8 – Vous pouvez sélectionner une ou plusieurs langues pour le programme d’installation.
Astuce
Il existe de nombreux sites Internet gratuits pour convertir divers formats d’images (BMP, PNG,
etc.) au format .ico.
Programmation Excel avec VBA
506
– Setup password (facultatif) : saisissez ici un mot de passe qui sera demandé lors de l’ins-
tallation si vous souhaitez limiter l’installation à des utilisateurs autorisés auxquels vous
fournirez le mot de passe.
11. Cliquez sur Next et, dans la nouvelle fenêtre, cliquez à nouveau sur Next (figure B-10).
12. Dans la dernière fenêtre qui s’affiche (figure B-11), cliquez sur Finish.
13. Inno Setup vous propose de compiler le programme d’installation. Choisissez Non. Le script
généré par l’assistant apparaît (figure B-12). Observez les lignes et rapprochez-les avec les
informations que vous avez fournies à l’assistant.
Figure B-12 – Inno setup a généré le script qui permet de créer le programme d’installation.
Programmation Excel avec VBA
508
14. Enregistrez le script sous le nom setup_audit.iss dans le dossier Install créé à l’étape 1.
Cliquez ensuite sur Compile dans l’onglet Build pour compiler le script et générer le programme
d’installation. Ce dernier, setup_audit.exe, est créé dans le dossier Install.
15. Fermez Inno Setup.
Info
Le fichier setup_audit.iss est le script Inno Setup de votre programme d’installation. Si vous
souhaitez apporter des modifications au programme d’installation directement via le script,
double-cliquez sur ce fichier pour l’ouvrir dans Inno Setup. Effectuez les corrections souhaitées,
puis cliquez sur Compile dans l’onglet Build pour générer à nouveau le programme d’installation
setup_audit.exe.
Figure B-13 – Inno setup vous invite à choisir la langue du programme d’installation.
Figure B-16 – Cliquez sur Installer pour procéder à l’installation du modèle complémentaire.
Programmation Excel avec VBA
510
Lancez maintenant Excel. À l’ouverture, un fichier nommé unins000.dat s’ouvre et affiche une
étrange formule (figure B-19).
Créer un programme d’installation pour vos applications Excel avec Inno Setup
Annexe B
511
Cela vient du fait que le programme d’installation place bien le fichier chap11.xlam dans le dossier
STARTUP d’Excel, mais il y crée aussi deux fichiers pour la désinstallation du programme : unins000.
exe et unins000.dat. Au lancement, Excel charge donc le modèle complémentaire, mais également
le fichier unins000.dat, source de cette formule. Nous corrigerons cela dans la section suivante.
Fermez le fichier unins000.dat et constatez que notre modèle est chargé : cliquez sur l’onglet Audit.
[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
Programmation Excel avec VBA
512
AppId={{FAEF6B78-2F1F-4E17-A212-2EDA0F4666EE}
AppName={#MyAppName}
AppVersion={#MyAppVersion}
;AppVerName={#MyAppName} {#MyAppVersion}
AppPublisher={#MyAppPublisher}
AppPublisherURL={#MyAppURL}
AppSupportURL={#MyAppURL}
AppUpdatesURL={#MyAppURL}
DefaultDirName={userappdata}\Microsoft\Excel\XLSTART
DisableDirPage=yes
DefaultGroupName={#MyAppName}
DisableProgramGroupPage=yes
LicenseFile=C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\
➥ sources xlvba\innosetup\licence.txt
InfoBeforeFile=C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\
➥ sources xlvba\innosetup\before.txt
InfoAfterFile=C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\
➥ sources xlvba\innosetup\after.txt
OutputDir=C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\
➥ sources xlvba\innosetup
OutputBaseFilename=setup_audit
SetupIconFile=C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\
➥ sources xlvba\innosetup\logo-excel.ico
Compression=lzma
SolidCompression=yes
[Languages]
Name: "english"; MessagesFile: "compiler:Default.isl"
Name: "french"; MessagesFile: "compiler:Languages\French.isl"
[Files]
Source: "C:\Users\mika\Desktop\Excel 2016 VBA\resssources\sources\sources
➥ xlvba\innosetup\chap11.xlam"; DestDir: "{app}"; Flags: ignoreversion
; NOTE: Don't use "Flags: ignoreversion" on any shared system files
[Icons]
Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
2. Pour faire disparaître les messages de début et de fin, supprimez les lignes qui sont en gras
dans le script ci-dessus, ou insérez un point-virgule au début de chacune des deux lignes pour
qu’elles soient désormais considérées comme des commentaires.
3. Pour empêcher la création des fichiers de désinstallation, ajoutez aux lignes du groupe [setup]
la ligne suivante :
Uninstallable = no
Créer un programme d’installation pour vos applications Excel avec Inno Setup
Annexe B
513
4. Pour afficher un message avant la fermeture du programme d’installation, ajoutez les lignes
suivantes en fin de script :
[Code]
var
LightMsgPage: TOutputMsgWizardPage;
procedure InitializeWizard;
begin
LightMsgPage := CreateOutputMsgPage(wpInstalling, ‘', ‘', ‘Audit JRI est
➥ maintenant installé sur votre ordinateur !'#13#13 + ‘Si Excel était ouvert
➥ au moment de l''installation, vous devez quitter l''application et la
➥ relancer afin d''activer l''application.'#13#13 + ‘Pour accéder aux
➥ fonctions du logiciel, activez son onglet.'#13#13 + ‘En cas de
➥ difficulté, n''hésitez pas à nous envoyer un email à [email protected]');
end;
Voilà, cet ouvrage s’arrête là ! Vous savez maintenant créer des programmes Excel professionnels
intégrant des interfaces utilisateurs complexes, interagissant avec d’autres programmes, les inté-
grer dans le ruban Excel sous forme d’onglet et les distribuer via des programmes d’installation.
Inno Setup offre de nombreuses autres possibilités. Si vous souhaitez approfondir vos connais-
sances de ce logiciel, consultez l’aide en ligne du site de l’éditeur.
Bon vent ! Et bonne programmation !
Index
Symboles appels
pile (des) 270, 274
+, opérateur arithmétique 158 procédures 116, 128, 130, 142
-, opérateur arithmétique 158 application
*, opérateur arithmétique 158 hôte 5, 15, 75
/, opérateur arithmétique 158 objet 17, 419, 420, 422, 423
&, opérateur de concaténation 152 procédures (de niveau) 421
argument
A fonctions 27
Accelerator, propriété 374 nommés 145
ActiveCell, propriété 60 passage (de) 121, 144
AddItem, méthode 403 passés 116
afficher arrêt
barre d’outils 108 enregistrement 58
boîte à outils 90 mode 269
explorateur 79, 82 automation 16, 176
fenêtre Code 91 AutoSize, propriété 361
fenêtre Proriétés 104 AutoTab, propriété 362
fenêtre UserForm 90 AutoWordSelect, propriété 363
feuille 348
AfterUpdate, événement 393 B
aide BackColor, propriété 354
code 148 BackStyle, propriété 354
VBA 85 barre doutils
ajouter afficher/masquer 108
module 131 Visual Basic Editor 107
procédure 135 barre d’outils Accès rapide 290
aligner, commande 339 base de registre. Voir registre
alignment, propriété 353 BeforeDragOver, événement 393
ancrage 110 BeforeDropOrPaste, événement 393
Programmation Excel avec VBA
516
Exit fonctions 26
événement 394 arguments 27
mot-clé 146, 282 Chr 202, 233
explorateur de projet 78, 79 conversion 173
afficher 79, 81 CreateObject 167, 175
masquer 79 Date 195
utiliser 80 DateAdd 261
explorateur d’objets 79, 82 DateDiff 256
afficher 82 Excel 219
aide 85 filter 243
fonctions 221 GetObject 166, 175
masquer 82 GetSetting 251
rechercher 87 InputBox 201
utiliser 83 InStr 192
exporter (module) 132, 433 Join 233
expressions 118 LBound 164
arithmétiques 22 LCase 237
opérateurs relationnels 180 Left 192, 235
Len 235
F LTrim 235
False, valeur booléenne 22 Mid 235
fenêtre MsgBox 206
ancrer 110 personnalisées 220
code 78, 91, 93, 96, 98, 100, 101 recommandations 223
exécution 272 Replace 236
propriétés 78, 103, 104 Resize 70
UserForm 78, 88, 90 Right 235
variables locales 269 RTrim 235
feuille 323 SaveSetting 250
afficher 348 StrComp 238
contrôles 104, 333 StrConv 237
création et mise en forme 323 String 234
créer 324 Trim 235
de calcul 426 TypeName 172
développement 323 types de données 172
dossier 80 UBound 164
masquer 348 UCase 237
mettre en forme 337 VarType 172
position 380 VBA 224, 225, 226, 227, 228
raccourci 374 Font, propriété 385
fichiers 497 For Each
Next, structure de contrôle 191
Filter, fonction 243 ForeColor, propriété 356
For
Next, structure de contrôle 187
Frame, contrôle 328
Programmation Excel avec VBA
520
N concaténation 155
logiques 215
Name, propriété 352 relationnels 180
Nothing, mot-clé 169 option
ancrage des fenêtres 111
O Base 1, instruction 161
objets Explicit, option 152
accéder 19 OptionButton, contrôle 330, 375, 410
affecter une macro 288 ordre de tabulation 362, 378
aide 85 définir 378
application 17, 419, 420, 422, 423 ouvrir
bibliothèque 16 boîte de dialogue 211
caractéristiques 14 Visual Basic Editor 75
classes 14
code 93 P
collections 14, 19, 191 paramètres
définition (propriétés) 39 fonctions 27
Dialog 211 Visual Basic Editor 110
événements 26, 426 pas à pas, commande 268
explorer 82 passage d’arguments 116, 121, 144
gestion 419, 427 apparition 144
instanciation 15 nommés 145
méthodes 25 valeur 123
modèles 15 PasswordChar, propriété 353
présentation (des) 13 PERSONAL.XLSB 48
propriétés 20 personnaliser
recherche 87 barre d’outils Accès rapide 290
référencer 176 boîte à outils 343
référentiel 19, 24 boutons de commande 286
ThisWorkbook 424 objets 288
variables 165 raccourcis clavier 286
Workbook 19 ruban 292
Worksheet 426 PictureAlignment, propriété 383
Office, Applications hôtes 16 PicturePosition, propriété 384
Offset, propriété 60 Picture, propriété 382
OLE Automation 176 PictureSizeMode, propriété 384
On Error, mot-clé 281 PictureTiling, propriété 384
onglet 331 pile des appels 270, 274
onglet personnalisé 294 plage de cellules
callbacks 300 courantes 70
validation XML 299 fin 70
opérateurs nommées 72
arithmétiques 158 redimensionner 70
comparaison 180 utilisées 70
Index
523
KeepScrollsVisible 372 R
LargeChange 374
Left 380 Raccourcis clavier
Locked 367 déplacement 56
Max 372 macro 286
MaxLength 367 Range, propriété 60
Min 372 rechercher
modifier 106 chaîne 239
MouseIcon 376 fenêtre Code 96
MousePointer 376 texte 87
MultiLine 367 redimensionner (plage) 70
Name 352 référence
Offset 60 absolue 58, 60
PasswordChar 353 boîte de dialogue 176
Picture 382 dossiers 81
PictureAlignment 383 relative 58, 68
PicturePosition 384 référentiel d’objet 19, 24
PictureSizeMode 384 registre 247
PictureTiling 384 clé 250, 251
Range 60 réinitialiser 267
Row 60 REM, mot-clé 138
RowSource 404 remplacer
ScrollBar 371 chaîne 236
Select 60 texte 96, 98
Selection 60 réorganiser (boutons) 342
SelectionMargin 368 Replace, fonction 236
SmallChange 373 Resize, fonction 70
SpecialEffect 356 Resume, mot-clé 281
StartUpPosition 380 retrait
Style 357, 368 automatique, option 140
TabIndex 378 bouton 140
TabKeyBehavior 369 ligne (code) 139
TabStop 379 Right, fonctions 235
TextAlign 369 Row, propriété 60
Top 380 RowSource, propriété 404
TripleState 369 RTrim, fonctions 235
UsedRange 70 ruban
Valeurs (des) 21, 39 contrôles 303
Value 357 images Microsoft Office 305
Visible 359 personnaliser 292, 294
Width 380
WordWrap 370
S
Public, mot-clé 121, 136, 175 sauvegarder (macros) 433
SaveSetting, fonction 250
Index
525
T variables 151
Boolean 159
TabIndex, propriété 378 concaténation 158
TabKeyBehavior, propriété 369 conversion du type 173
TabStop, propriété 379 dates 159
TabStrip, contrôle 331 déclarer 151
Tag, propriété 379 définir 172
TextAlign, propriété 369 de matrice 242, 243
TextBox, contrôle 327, 366, 367, 369, 400 durée de vie 174
ThisWorkbook, objet 424 forcer la déclaration 152
ToggleButton, contrôle 330 info-bulles 269
Top, propriété 380 locales 123, 269
trait de soulignement 137 matrice 161, 233
tri de données 216 numériques 157
Trim, fonctions 235 objets 165, 169
TripleState, propriété 369 personnalisées 169
True, valeur booléenne 22 portées 174
Type, mot-clé 169 statiques 123, 175
TypeName, fonction 172 String 155, 156
types de données 155 types 155
chaîne de caractères 21 validation 171
constantes 23 Variant 160
conversion 173 vérifier 171
valeur 21, 22 Variant, variables 160
validation 171 VarType, fonction 172
vérifier 171 vérification (syntaxe) 148
verrouiller un projet 434
U virus, macros 429
UBound, fonction 164 Visible, propriété 359
UCase, fonction 237 Visual Basic
underscore 137 mots-clés 38, 118
uniformiser présentation 13
espace, commande 340 rechercher 87
taille, commande 340 structure 115
UsedRange, propriété 70 Visual Basic Editor
UserForm, fenêtre 88 ancrer les fenêtres 110
barres d’outils 107
V développer dans 115
environnement 75, 78
valeurs
explorateur 79, 82
booléennes 22, 159
fenêtre 88, 91, 103
des contrôles 357
lancer 75
numériques 21, 157
paramétrer 110
Value, propriété 357
quitter 77
Index
527
W Z
While
Wend, structure de contrôle 180 zone de liste 327
Width, propriété 380 zone de texte 327
With
End With, structure 39, 42
WithEvents, mot-clé 420
WordWrap, propriété 370
Workbook
événements 424
objets 19, 424
Worksheet, objet 426