Cours complet sur les macros VBA
...
Structure des procédures
Une application est constituée essentiellement de l'interface utilisateur, formée elle-même de plusieurs contrôles, et de procédures qui génère des actions. A présent, analysons la structure d'une procédure.
La syntaxe d'écriture d'une procédure est la suivante :
[Public / Private] [Static] Sub Nom_proc (arguments)
[Déclarations]
[Instructions]
[exit Sub]
[Instructions]
End Sub
Le mot Sub peut ou non être précédé des options suivantes :
o Avec Public, la procédure peut être appelée depuis n'importe quelle instruction de l'application.
o Avec private, la procédure ne peut être appelée qu'à l'intérieur de la même feuille ou du même module.
Pour cela, prenons un simple exemple :
Private Sub Form_Load()
Dim DateNaissance
Dim Message, Titre As String
Message = "Date de naissance ?"
Titre = "Entrez votre date de naissance : "
DateNaissance = InputBox(Message, Titre)
If DateNaissance <> "" Then
DateNaissance = Format(DateNaissance, "Long Date")
MsgBox DateNaissance, vbOKOnly + vbInformation, "Vous êtes né(e) le"
End
Else
While DateNaissance = ""
MsgBox "Entrez une date", vbOKOnly + vbExclamation, "Attention!"
DateNaissance = InputBox(Message, Titre)
Wend
DateNaissance = Format(DateNaissance, "Long Date")
MsgBox DateNaissance, vbOKOnly + vbInformation, "Vous êtes né(e) le"
End
End If
End Sub
Le but de ce programme est certes inutile, vous direz-vous, puisqu'il consiste juste à demander la date de naissance à quelqu'un et de l'afficher par la suite. Mais les instructions de cette procédure renferment une partie des bases de la programmation en VB6.
Ce n'est pas important si vous n'avez pas compris toutes les instructions de cette procédure. Contentez-vous pour l'instant de lire cette procédure et observez simplement de quoi peut être composée une procédure.
A présent, passons à une analyse simplifiée de cette procédure :
Cours 3 : Les variables et les constantes
Les variables sont des données ou des valeurs qui peuvent changer à l'intérieur d'une application. C'est pourquoi, il est fort utile de les nommer par un nom, de déclarer quel genre de variables est-ce (nombre entier, nombre décimal, lettres...) et leur affecter, lorsque cela est nécessaire une valeur.
La longueur maximale du nom d'une variable est de 255 caractères. Ceux-ci peuvent être des chiffres, des lettres ou autres symboles. Notez que ce nom doit obligatoirement commencer par une lettre.
En effet, Visual basic classe les variables en fonction de la valeur affectée à la variable. Ainsi, une variable déclarée comme du type numérique ne peut pas recevoir une valeur chaîne de caractère, ainsi qu'à l'inverse.
Notez que si vous ne déclarez pas une variable, Visual Basic se chargera d'affecter par défaut un type de variable (Variant) à celle-ci. Une variable du type Variant peut aussi bien recevoir des données numériques que des chaînes de caractères. Tout dépend de ce que vous avez affecté à cette variable.
A présent, observons de plus près les différents types de variables :
Type de données Mot clé Occupe Limite de valeurs
Octet Byte 1 octet 0 à 255
Logique Boolean 2 octets True(-1) ou False(0)
Entier Integer 2 octets -32 768 à 32767
Entier long Long 4 octets -2 147 483 648 à 2 147 483 647
Décimal simple Single 4 octets Nombre réel avec 7 chiffres après la virgule
Décimal double Double 8 octets Nombre réel avec 15 chiffres après la virgule
Monétaire Currency 8 octets Nombre réel avec 15 chiffres avant la virgule et 4 chiffres après la virgule
Date Date 8 octets 1er janvier 100 au 31 décembre 9999
Objet Object 4 octets Toute référence à des types Object
Chaîne de caractères String 10 octets + longueur de chaîne Chaîne de caractère dont la longueur ne doit pas excéder 2^31 caractères
Variant (avec chiffres) Variant 16 octets toute valeur numérique jusqu'à l'étendue d'un double
Variant (avec lettres) Variant 22 octets+longueur de chaîne Même étendue que pour un String de longueur variable
Défini par l'utilisateur Type - L'étendue de chaque élément est la même que son type de données
Notez que les types de variables les plus utilisées sont : String, Integer, Long, Single, Double et Currency.
Pour utiliser des variables, il est normalement obligatoire de les prédéfinir, soit dans la section Déclarations de la liste déroulante Objet, soit en début de procédure ou de fonction. Un programme où les variables sont bien déclarées rend un programme plus facile à comprendre, à lire et surtout à corriger en cas d'erreurs. Certes, il n'est pas obligatoire de les déclarer mais faites-le quand même, c'est un conseil. Si vous êtes prêt à déclarer une variable que vous voulez utilisez mais que vous êtes un étourdi, alors, utilisez simplement l'instruction Option Explicit (à placer dans la section Déclarations de la liste déroulante Objet) qui vous oblige à chaque fois à déclarer toutes vos variables avant de pouvoir exécuter l'application.
3.1 Déclaration explicite d'une variable
Pour déclarer une variable, on utilise l'instruction Dim suivi du nom de la variable puis du type de la variable. Reprenons l'exemple du cours 2 :
Dim DateNaissance
Dim Message, Titre As String
Remarquez que la 1ère déclaration ne contient pas d'information sur le type de variable. Si vous déclarez une variable sans donner d'information sur le type de variable que c'est, alors, cette variable (DateNaissance) aura par défaut une variable du type Variant. Si vous avez bien lu l'exemple précédent, vous aurez compris qu'il s'agit ici d'une variable de type Variant (avec chiffres) qui lui est affectée par défaut. La 2ème déclaration est par contre explicite. Vous pouvez aussi mettre 2 variables sur une même ligne à condition que le type de variable est le même pour les 2 et en les séparant par une virgule.
3.2 Déclaration implicite d'une variable
Il existe une autre méthode de déclarer des variables. Pour cela, il suffit d'ajouter juste avant la variable, un symbole spécifique. Voici la liste des symboles avec le type de variable auxquelles ils se rapportent :
Symbole Type de variable
% Integer
& Long
! Single
# Double
@ Currency
$ String
Dans l'exemple ci-après, les deux premières instructions sont équivalentes à la troisième :
Dim V1 as Integer
V1 = 25
V1% = 25
En général, toute variable déclarée a une portée limitée. Cette même variable a une valeur nulle au départ. De plus, elle ne s'applique pas forcément à toutes les procédures d'une application. Tout dépend de 2 éléments : la manière de déclarer et l'emplacement de la variable.
Contrairement aux variables dont les valeurs diffèrent souvent, les constantes ont des valeurs fixes. Mais tout comme les variables, on affecte aux constantes, un nom et une valeur qui est elle, fixe. De plus, les constantes se définissent de la même façon que les variables. Tout dépend donc de l'endroit où est défini la constante. Le mot Const peut être précédé de l'option Public pour que toutes les feuilles et modules de l'application puissent y accéder.
Attention cependant à ne pas affecter à une constante des noms identiques aux constantes prédéfinies (VbSystemModal, VbOkOnly, VbArrow...) dans Visual Basic !
Prenons l'exemple du taux de TVA :
Const TVA = 20.6
TotalTTC=PrixHorsTaxe x (1 + (TVA / 100))
Cours 4 : Les tableaux
Les tableaux de valeurs sont utiles lorsque l'on manipule des données en tout genre. Ainsi, dans un carnet d'adresses, vous pouvez stocker toutes les adresses dans un tableau structuré. Par exemple :
Dim Adresses (1 to 50) As String
Adresses(1) = "12, avenue de la Fayette, Paris"
........
Adresses(50) = "4, rue de la Paix, Paris"
Comme vous pouvez le constatez, la définition d'un tableau ressemble beaucoup à celle d'une variable à la seule différence que vous devez donner une limite aux nombres de valeurs contenues dans un tableau. Pour appeler une des variables du tableau, il faut faire précéder de la variable, un numéro qui permet d'identifier la variable spécifique recherchée parmi toutes celles du tableau. Ce tableau est à une dimension,
Voici un exemple à 2 dimensions :
Dim Adresses (1 to 50, 1 to 50) As String
Adresses(1,0) = "Vincent"
Adresses(1,1) = "12, Rue de la paix, Paris"
.....
Adresses(50,0) = "Philip"
Adresses(50,50) = "7, Boulevard de la Villette"
Notez qu'avec les fonctions LBound et UBound, vous pouvez obtenir les limites inférieures et supérieures d'un tableau.
Il existe une autre façon de définir un tableau :
Dim Adresses(50) As String
Adresses(0) = "12, avenue de la Fayette, Paris"
........
Adresses(49) = "4, rue de la Paix, Paris"
Avec cette méthode, les limites du tableau ne sont pas définies. Notez que le nombre d'adresses est de 50 mais la numérotation va de 0 à 49 et non de 1 à 50. Il existe cependant un moyen pour que la numérotation commence à 1 : c'est en utilisant l'instruction Option Base (par exemple : Option Base = 1) qu'il faut placer dans la section Déclarations.
Pour construire un tableau, on peut aussi utiliser la fonction Array :
Exemple :
Dim Semaine, Jour As String
Semaine = Array("lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche")
Jour = (3) 'retourne jeudi
Une autre méthode consiste en la création de tableaux dynamiques. Pour comprendre cette méthode, prenons un exemple :
Dim Adresse() As String
Dim NbAdresses As Integer
'Nouvelle adresse
NbAdresses = nbAdresses + 1
Redim Adresse (NbAdresses)
Adresse (NbAdresses) = "75, Rue Lecourbe, Paris"
Ainsi, à chaque fois que l'on lance cette procédure, le nombre total d'adresses (NbAdresses) est incrémenté (augmenté) de 1 et la nouvelle adresse est placé à la fin du tableau. en effet, Redim a pour effet de reformater le tableau, et donc, tout ceux qui était dans le tableau est aussi effacé sauf la dernière valeur entrée.
Cependant, il existe un moyen de conserver les données déjà présentes dans le tableau. Pour cela, on fait appel à l'instruction Preserve :
Redim Preserve Adresse (NbAdresses)
Enfin, pour terminer, il est possible d'effacer toutes les données d'un tableau. Pour cela, on utilise l'instruction Erase suivi du nom du tableau.
Cours 5 : Structure des conditions (tests, boucles)
1.1 La structure : If...Then...Else...end If
Voici un exemple de structure simple avec l'instruction If :
If condition Then
Instructions 1
else
Instructions 2
End if
Interprétation : Si la condition est vérifiée alors les instructions 1 sont exécutées sinon les instructions 2 sont exécutées à la place. (Notez que l'on peut utiliser des opérateurs logiques And (et) et Or (ou) pour que plusieurs conditions doivent d'abord être vérifiées avant de pouvoir exécuter les instructions suivantes.). Le mot Else et les instructions qui suivent ne sont pas obligatoires.
Voici un autre exemple de structure avec If mais un peu plus complexe :
If Condition 1 Then
Instruction 1
ElseIf Condition 2 Then
Instruction 2
Else
Instructions X
End If
Interprétation : Si la condition 1 est vérifiée alors les instructions 1 sont exécutées. Sinon si la condition 2 est vérifiée alors les instructions 2 sont exécutées. Sinon, si aucune de ces deux conditions ne sont vérifiées alors les instructions X sont exécutées.
Il existe une autre structure simplifiée de If mais qui moins utilisée :
Variable = IIf (Condition, instructions 1, instructions 2)
Interprétation : Si la condition est vérifiée alors les instructions 1 sont exécutées sinon les instructions 2 sont exécutées à la place.
L'instruction IIf(Immediate If) est utile lorsque qu'il n'y a que une ou deux instructions en fonction d'une condition. Par ailleurs, la valeur retournée par la condition est affectée à une variable.
1.2 La structure Select Case...End Select
Lorsque l'on doit effectuer toute une série de tests, il est préférable d'utiliser la structure Select Case...End Select au lieu de If...Then...End if.
Ainsi, les deux exemples suivants sont équivalents :
Select Case Semaine
Case 1
Jour = "Lundi"
Case 2
Jour = "Mardi"
Case 3
Jour = "Mercredi"
Case 4
Jour = "Jeudi"
Case 5
Jour = "Vendredi"
Case 6
Jour = "Samedi"
Case 7
Jour = "Dimanche"
Else
MsgBox "erreur", vbOKOnly
End Select If Semaine = 1 Then
Jour = "Lundi"
ElseIf Semaine = 2 Then
Jour = "Mardi"
ElseIf Semaine = 3 Then
Jour = "Mercredi"
ElseIf Semaine = 4 Then
Jour = "Jeudi"
ElseIf Semaine = 5 Then
Jour = "Vendredi"
ElseIf Semaine = 6 Then
Jour = "Samedi"
ElseIf Semaine = 7 Then
Jour = "Dimanche"
Else
MsgBox "erreur", vbOKOnly , "Note"
End If
Interprétation : Si la variable Semaine vaut 1, alors la variable Jour reçoit la valeur Lundi. Si la variable Semaine vaut 1, alors la variable Jour reçoit la valeur Mardi. (Etc...). Si la variable Semaine ne reçoit aucune valeur comprise entre 1 et 7, alors un message indiquant une erreur est affiché.
2.1 La structure For..Next
La structure For...Next est utile lorsqu'on doit répéter plusieurs fois la même instruction.
Exemple :
For J = 1 To 10
T(J) = J
Next
Interprétation : Dans cette boucle, l'instruction "T(J)=J" est répétée 10 fois c'est à dire jusqu'à ce que J soit égale à 10. A chaque passage, l'instruction "T(J)=J" affecte à T(J) les valeurs 1 à 10.
Pour que l'instruction soit exécutée une fois sur 2, vous pouvez utiliser l'instruction Step :
For J = 1 To 10 Step 2
T(J) = J
Next
Interprétation : Dans cette boucle, l'instruction "T(J)=J" affecte à T(J) les valeurs 1,3,5,7,9.
2.2 La structure For Each...Next
Cette structure est moins utilisée que la précédente. Elle sert surtout à exécuter des instructions portant sur un tableau. Exemple :
Dim Semaine(1 to 7) As String
Dim Jour As Variant
Semaine(1) = "Lundi"
'Etc...
For Each Jour In Semaine()
Combo1.AddItem Jour
Next
Interprétation : Pour chaque Jour de la Semaine, on ajoute à la liste combinée, la valeur de la variable Jour jusqu'à ce que l'indice de la semaine soit égale à 7.
2.3 Les structures Do...Loop et While...Wend
Avec ces boucles, le nombre de fois où sont répétées les instructions est indéfini.
Les deux exemples qui suivent sont équivalents :
i = 1
Do
T(i) = i
i = i + 1
Loop Until i > 10 i = 1
While i < 10
T(i) = i
i = i + 1
Wend
Interprétation : La variable i est initialisée à 1 au départ. Les instructions qui suivent sont exécutées jusqu'à ce que i soit supérieure à 10. A chaque passage, on affecte à la variable T d'indice i la valeur de i.
Il existe d'autres variantes de ces boucles et qui sont chacune équivalentes :
Do
Instructions
Loop While Condition Do Until Condition
Instructions
Loop Do While Condition
Instructions
Loop
Cours 6 : Les contrôles standards
Ne vous fiez pas aux apparences. Le Pointeur n'est pas un contrôle. Il sert juste à déplacer et à redimensionner un contrôle placé sur une feuille.
Le contrôle PictureBox sert à afficher une image en mode point, une icône ou un métafichier. Il sert aussi à regrouper des boutons radio. Remarquons que ce contrôle est le seul qui puisse être placé dans une feuille MDI. En effet, essayez de placer d'autres contrôles sur une feuille MDI, vous verrez que ça ne marche pas !
Le contrôle Label sert à placer du texte qui ne peut être modifié ou effacé lors de l'exécution de l'application.
Le contrôle Textbox sert à placer du texte qui peut être ou non modifié par l'utilisateur lors de l'exécution de l'application.
Le contrôle Frame sert à regrouper plusieurs contrôles (checkbox, optionbutton,...) dans un cadre avec un titre que vous pouvez modifier dans ses propriétés.
Le contrôle CommandButton sert à afficher un bouton de commande qui lorsque l'on clique dessus, la portion de code écrite dans sa procédure est exécutée.
Le contrôle Checkbox sert à placer une case à cocher. En plaçant plusieurs cases à cocher dans une application, l'utilisateur aura le choix entre plusieurs options. Selon les options sélectionnées, une portion de code sera exécutée.
Le contrôle OptionButton s'utilise comme un contrôle CheckBox. Contrairement aux cases à cocher, une seule option peut être sélectionnée parmi un groupe d'options composées de boutons radio.
Le contrôle ComboBox laisse à l'utilisateur le choix de sélectionner un élément parmi d'autres dans une liste.
Le contrôle ListBox s'utilise comme le contrôle ComboBox sauf que dans la liste d'option, plusieurs options sont affichées simultanément.
Les barres de défilement permettent de lire la suite du contenu d'une fenêtre trop large ou trop longue pour être affichée en une seule fois.
Le contrôle Timer permet de générer un événement à intervalle régulier, par exemple dans une horloge où toutes les minutes, l'aiguille des minutes bouge. Notons que le contrôle Timer n'apparaît pas pendant l'exécution d'une application.
Le contrôle DirListBox permet à l'utilisateur de choisir un des lecteurs de disques de l'ordinateur. Les noms des lecteurs sont affichés dans une liste non modifiable.
Le contrôle DirListBox permet d'afficher la liste de tous les répertoires d'un lecteur de disque.
Le contrôle FileListBox permet d'afficher la liste de tous les fichiers d'un répertoire du disque.
Le contrôle Shape permet de dessiner des figures dans une feuille (rectangle, carré, cercle). Le type de forme est choisi dans la propriété Shape du contrôle.
Le contrôle Line permet de tracer des lignes dans une feuille. La propriété BorderStyle permet de choisir le type de ligne que vous désirez : continu, invisible, pointillé...
Le contrôle Image permet tout comme le contrôle PictureBox d'insérer des images en mode point, icône, ou métafichier. Cependant, il requiert moins de ressource et donc diminue la taille de votre application.
Le contrôle Data permet d'accéder aux données provenant de bases de données.
Le contrôle OLE permet d'incorporer ou de lier un objet provenant d'une autre application (feuille Excel, feuille Access,...).
Avant tout, pour pouvoir utiliser les boîtes de dialogue communes, il faut ajouter le contrôle CommonDialog dans votre boîte à outils. Pour ce faire, placer votre souris sur la boîte à outils et cliquez sur le bouton droit. Ensuite, choisissez la commande "Composants". Une liste de tous les contrôles apparaît alors. Celui qui nous intéresse ici, c'est le contrôle CommonDialog. Cochez la case du contrôle Microsoft Common Dialog Control 6.0 (SP3) et appuyez sur le bouton Appliquer. Le contrôle CommonDialog va alors apparaître sur votre boîte à outils. A présent, vous pouvez l'utilisez dans vos applications. NB : commencez par modifier les propriétés du contrôle avant d'utiliser les méthodes respectives.
