VISUAL BASIC

Le Langage Visual Basic

1. Généralités:
Le langage VB est utilisé pour effectuer les traitements sollicités, en principe, à partir de l'interface.
Nous présentons dans cette partie l'essentiel du langage qui permet de réaliser les applications attendues.

2. Les fichiers d'une application:

Une application est associéE à un fichier dit "projet" portant le même nom et dont le rôle est de contenir
tous les noms de fichiers (feuilles, modules,..)qui constituent l'application.
2.1 Fichiers feuilles (*.FRM)
La feuille est l'entité de base d'une application VB. Ce fichier a pour extension FRM (*.FRM)
2.1.1- Les déclarations (constantes, variables) utilisées dans la feuille.
2.1.2- Les procédures événements: ce sont les procédure qui de déclenchent suite à un événement survenu à un
objet de la feuille. Ce sont des procédures du type:
Sub NOMOBJ_Click( )
.....
End Sub
2.1.3- Les procédures générales appelables par le code au niveau de la feuille. Ce sont des modules du type Sous
programmes (Sub NOMPROC( )...) ou Fonction ( Function NOMPROC( )...). On évoquera cela plus en détail
plus loin.

2.2. Fichiers modules:

- Ce sont des fichiers où l'on mettra en place du code (déclarations, procédures, fonctions) qui pourra
être sollicité par tous les autres fichiers (feuilles ou modules)
- Ces fichiers portent extension BAS (*.BAS)

2.4. Fichiers exécutables:

- Une fois l'application mise au point on demande à créer un exécutable pour l'exploiter.
- Cela permet de ne pas fournir le source et tout l'environnement de VB. Il est à noter que l'utilisateur
n'a pas à payer du "run_time" pour utiliser les applications VB.

2.5 Les éléments de l'interface:

Les feuilles sont des cadres (contenant) dans lesquelles on viendra placer des objets (contrôles). Parmi
ces contrôles nous en avons 22 qui sont prédefinis:

1- Contrôle image (PictureBox): pour afficher une image, servir comme cadre à d'autres contrôles.
2- Etiquette (Label): affichage d'un texte (pas de saisie)
3- Champ de saisie (TextBox): affichage et saisie de texte (possibilité sur plusieurs lignes: taille 64 ko).
4- Cadre (Frame): moyen de regroupement d'autres contrôles (boutons à options) ou besoin d'esthétique.
5- Bouton de commande (CommandButton): moyen pour solliciter un traitement par un click par exemple.
6- Case à cocher (CheckBox): moyen de saisie d'une option du type binaire (oui/non).
7- Liste combinée (ComboBox): liste simple munie d'un champ de saisie.
8- Liste simple (ListBox): affichage d'une liste d'éléments avec possibilité de choix d'un élément (ou plusieurs).
9- Barres de défilement horizontale (HScrollBar).
10- Barres de défilement verticale (VScrollBar).
11- Minuterie (Timer): non visible lors de l'exécution. Cela permet de générer périodiquement un événement
(qui déclenche un traitement).
12- Liste d'unités (DriveListBox): liste et choix d'une unité disque.
13- Liste de répertoire (DirListBox): choix d'un répertoire dans une unité disque.
14- Liste de fichiers (FileListBox): choix d'un fichier dans un répertoire.
15- Forme (Schape): dessin d'une forme (rectangle, carré, coin arrondi ou non, cercle ou ellipse).
16- Ligne (Line): dessin d'un segment de droite.
17- Dessin (Image): forme simplifié de l'image. Elle est utilisée pour permettre la modification des dimensions
d'une bitmap.
18- Contrôle "données" (Data): accès aux bases de données
19- Client OLE (OLE): incorporation d'objet provenant d'autres applications.
20- Grille (Grid): affichage en tableau du type Tableur.
21- Boîte de dialogue communes (CommonDialog): appel des boîtes de dialogues standards de Windows.
D'autres contrôles pourront être ajoutés (ou retirés). Ce sont les contrôles personnalisés (extension *.VBX (16
bits) ou OCX (16 ou 32 bits).

3. Les variables:

- Les noms de variables suivent les conventions classiques (1er lettre alphabétique,...).
- La longueur peut aller jusqu'à 255 caractères.

3.1. Types de variables:

On a la possibilité d'utiliser les types suivants:

- Integer: entier sur 2 octets (%)
- Long: entier sur 4 octets (&)
- Single: flottant sur 4 octets (!)
- Double: flottant sur 8 octets (#)
- Currency: entier virgule fixe sur 8 octets ((4 décimales) (@)
- String: caractère 1 octet/caractère ( 216 ou 232) ($)
- Byte: 1 octet (0 à 255) entier non signé.
- Boolean: 2 octets (True, False).
- Date: 8 octets (1er janvier 100 à 31 décembre 9999)
- Variant: tout valeur numérique, chaîne, date/heure
-Type: définition d'un type.
- Le "type" permet de créer les enregistrements de fichier:
- Le type Variant: C'est le type par défaut. La variable peut contenir des données de types différents. VB utilise
le contexte pour effectuer les conversions nécessaires.

3.2. Déclaration de variables:

3.2.1 Déclaration implicite:

+ Par emploi de suffixe au niveau du nom de la variable (%, &, !, #, @, $,

I %= 3 (Integer)
3.2.2 Déclaration explicite:

On emploie: Dim, Static, Private, Public

Exemple: Dim I As Integer
Static CH As String
Dim: chaque fois que Dim est exécuté, la variable est mise à 0, à vide, à empty selon le type (allocation
automatique).
Static: permet à la variable de garder sa valeur d'un appel à un autre du module où la variable est
déclarée (allocation statique de la mémoire).

3.2.3 Les tableaux:

Dim Tab(1 to 10) As Integer

Dim Tab2(1 to 10, 101 to 200) As Integer

Emploi de tableaux dynamiques:

Dim tab( )

ReDim Tab(3 to 10)

ReDim Tab(20) ' reinitialisation de Tab

ReDim Preserve Tab(10) ' Pas de reinitialisation

3.2.4. Portée des variables:
Les variables peuvent avoir une portée locale (reférençable dans la procédure) ou global (reférençable
aussi ailleurs).

Portée locale: emploi de Dim, Private, Static (Dim et Private sont équivalents)
Aspect local:
+ Procédure ou fonction
+ Feuille
Portée globale: emploi de Public dans la section déclaration d'un module.

3.2.5. Les constantes:

Une constante est défini par sa valeur (cas courant) et aussi par déclaration explicite (emploi de Const)
Const PI = 3.14

3.2.6. Les instructions de contrôle:

A)- Commentaire:
Emploi de la (') ou du mot clé "Rem"
B)- Affectation:
X=4
C)- If...Then...Else:

- Ecriture sur une seule ligne:

If cond Then action1 Else action2

- Ecriture sur plusieurs lignes:

If condition Then
Action1
Else
Action2
End If

- Opérateur de comparaison:
= <> < <= > >=
- Connecteurs logiques:
And, Or et Not

D)- IIF (Intermediate If)

var=IIF(condition, partie vraie, partie fausse)
si condition est vraie alors var= partie vraie
sinon var= partie fausse

E)- GoTo
Pour faire référence à une étiquette.
GoTo étiquette

F)- Select Case

Select Case Val
Case 0
' instructions cas 0
Case 5, 7, 10
' instructions cas 5, 7 et 10
Case 1 to 4
' instructions cas 1, 2, 3 et 4
Case Is >= 10
' instructions cas Val >= 10
Case Else
' instructions des autres cas
End Select
G)- Traitements répétitif:
G.1)- For...Next
For I=deb to Fin [Step pas]
......
[Exit For] 'Exit permet de quitter avant la fin
Next [I ]

G.2)- For Each.....Next

For Each élément In groupe
......
[Exit For]
Next élément

Dim Jours, j 'Jours et j sont Variant

' Remplacement dynamique du Tableau Jours
Jours= Array ("Lundi", "Mardi", ...., "Dimanche")
For Each j In Jours
NOMJOUR$=Jours(j)
.....
Next

G.3)- Do.....Loop

Forme 1 Do [{ While | Until} Condition]

.....
[Exit Do] ' sortie forcée
Loop

Forme 2 Do
.....
[Exit Do]
Loop [{While | Until} Condition

G.4)- While .... Wend

While Condition
.....
Wend

H)- La fonction Choose

Choose (index, exp1, exp2, ..., expN)

si index=1 Choose retourne exp1

=2 Choose retourne exp2

=N Choose retourne expN

I)- L'instruction With

Elle permet la mise en facteur d'un qualificatif; ce qui rend le code plus lisible.
With Objet
......
End With

3.2.7. Les sous programmes

A)- Appel interne GoSub....Return

B)- Procédure type Sub

 Définition
Sub Nom_proc(param1, param2, ....)
' Traitement
End Sub
parami : nom_param As type

' Exemple
Sub SOMME(S As Integer, N As Integer)
Dim I As Integer
S=0
For I=1 to N
S=S+I
Next
End Sub

Appel CALL SOMME(S,10)

ou
SOMME S , 10

C)- Procédure type Function

Définition
Function nom_fonct(param1, param2, ...) As type
' Traitement
nom_fonct=exp 'résultat de la fonction
Exit Function
.....
nom_fonction=exp
End Function

param i : nom_param As type

' Exemple
Function SOMME (N As Integer) As Integer
Dim I As Integer, S As Integer
S=0
For I=1 To N
S=S+I
Next
SOMME=S
End Function

Appel:

S=SOMME(10)

D)- Mode de passage des arguments

+ Par défaut le passage se fait par référence (ByRef) (on dit aussi passage par adresse). Cela veut dire
que les arguments peuvent être modifiés par la procédure.
+ Le passage pourra se faire par valeur (ByVal). Dans ce cas, une copie de la valeur de l'argument est
passée à la procédure.
+ Si le mot clé Optional précède le paramètre cela veut dire que l'argument correspondant pourra être
fourni ou non.

Fonctions et instructions VB
Les opérateurs
- Arithmétiques:
+ - * (addition, soustraction, multiplication)
/ (division en virgule flottante)
 \ (division entière)
- Opérateurs de comparaison:
< <= > >= = <>
- Opérateurs logiques:
Not And Or Xor
- Opérateurs chaînes de caractères:
& : concaténation ("A" & "B" "AB")
on peut utiliser + "A"+"B" "AB"
Like : comparaison au sens d'un masque.
"A*" : toute chaîne commençant par A
"A?B*": toute chaîne commençant par A et dont le 3eme lettre est un B.
Les fonctions:
- Asc : Asc("A") 65 Asc("AX") 65
- chr : Chr(65) "A" (Code ANSI : 0 - 255)
- Val : Val("11 Rue 205") 11
- Str : Str(12) "12"
- IsNumeric : IsNumeric(variant) (vrai : numérique)
- IsEMpty : IsEmpty(variant) (vrai : non initialisé)
- IsNull : IsNull(variant) ( vrai : c'est Null)
- IsArray : IsArray(var) (vrai : var est un tableau)
- IsMissing : IsMissing(argument) (vrai : argument non fourni)
- VarType : VarType(variant) type du variant

Traitements des chaînes de caractères:

- Lors de la comparaison entre chaînes de caractères on peut ou nn faire la différence entre majuscule et
minuscule. Pour cela on utilise "Option Compare".
Option Compare Binary
' "a" est différent de "A"
Option Compare Text
' "a" est égal à "A"
- Fonctions relatives aux chaînes:
Space(3) : retourne 3 espaces
String(3,*) : retourne "***"
Len("ABC") : retourne la longueur = 3
InStr("ABCD", "B") : retourne 2 (Position de B)
Left("ABCD", 2) : retourne "AB"
Right("ABCD", 2) : retourne "CD"
Mid("ABCD", 2,1) : retourne "B" (à partir du 2eme prendre 1 caractère).
Mid(CH$, 2, 1)="X" : CH$="ABCD" "AXCD"
LTrim(" AB ") : retourne "AB "
Rtrim(" AB ") : retourne " AB"
Trim(" AB ") : retourne "AB"
LCase("ABCD") : retourne "abcd"
Ucase("abcd") : retourne "ABCD"

- Fonctions relatives aux dates:

- Date : date système jj-mm-aaaa
- modifier la date : Date = "27/01/1997"
(forme à utiliser : jj-mm-aaaa , jj-mm-aa
séparateur : - ou /).
- Time : heure système hh:mm:ss (sur 24 heures)
- modifier l'heure : Time = "12:30"
(forme à utiliser : hh, hh:mm, hh:mm:ss).
- Timer : heure sous forme de nombre de secondes
écoulées depuis minuit.
- Now : retourne un variant qui représente la date et
l'heure système sous la forme date.heure.
- Day(Now) : N° du jour de la date courante.
 - Month(Now) : N° du mois.
- Year(Now) : l'année courante.
- Hour(Now) : heure courante (0 à 23)
- Minute(Now) : minute courante (0 à 59)
- Second(Now) : seconde courante (0 à 59)
- IsDate(variant) : vrai : variant une une date.

Emploi des fichiers

1. Généralités:
VB possède sa propre gestion de fichier que nous allons présenter dans cette partie. Mais remarquons
qu'il est muni de la possibilité d'accès aux données gérées à l'extérieur par un SGBD (access, Oracle, ...).
L'emploi des fichiers, en particulier texte, reste cependant très important; car souvent des données sont
présentées sous forme texte (ASCII) qu'il y a lieu de traiter pour alimenter éventuellement une base de données.

2. Commandes sur des fichiers et répertoire:

2.1. Création d'un répertoire:
MkDir "C:\REP_ANC\REP_NOU"
Cette commande crée le répertoire REP_NOU.
2.2. Suppression d'un répertoire:
RmDir "C:\REP_ANC\REP_NOU"
Cette commande supprime le répertoire REP_NOU
2.3. Changer de répertoire courant:
ChDir "C:\REP_ANC\REP_NOu"
Cette commande rend le répertoire REP_NOU courant.
2.4. Connaître le répertoire courant:
CurDir répertoire courant du lecteur par défaut.
CurDir "C:" répertoire courant du lecteur C.
2.5. Liste des fichiers d'un répertoire:
La commande Dir permet d'obtenir cela. L'exemple suivant montre
la manière d'utilisation:
Fic$=Dir("C:\REP_ANC\*.DOC")
Do While Fic$ <> ""
' traitement du nom de fichier courant .
' Affichage dans un objet liste
Liste.AddItem Fic$
Fic$=Dir

Loop
Ce programme affiche dans l'objet "Liste" tous les fichiers .DOC du répertoire REP_ANC. Remarquons
l'emploi de * et ? qui sont les même convention que pour Ms-DOS.

2.6. Renommer un fichier ou répertoire:

- Name "C:\REP_ANC\DOC1.DOC" AS "C:\REP_ANC\TEXT1. DOC"
(Le fichier DOC1.DOC devient TEXT1.DOC)
- Name "C:\REP_ANC" AS "C:\DOCUMENT"
(Le répertoire REP_ANC devient DOCUMENT)
- Name "C:\DOCUMENT\TEXT1.DOC" AS "C:\TEXT1.DOC"
(Le fichier TEXT1.DOC est déplacé du répertoire DOCUMENT
pour venir dans "C:\").
2.7. Copie de fichiers:
FileCopy "a: VB.DOC" , "C:\DOCUMENT\VB4.DOC"
2.8. Suppression de fichiers:
 Kill "C:\*.BAK"
2.9. Accès à la taille d'un fichier:
I% = FileLen("C:\TEXT1.DOC")
2.10. Date et heure d'accès aux fichiers:
FileDateTime("C:\TEXT1.DOC")
(Date et heure du dernier accès au fichier TEXT1.DOC)
2.11. Attributs d'un fichier:
GetAttr("C:\TEXT1.DOC")
SetAttr "C:\TEXT1.DOC" , ATTR_READONLY

3. Traitement des fichiers

3.1. Mode d'accès:
VB permet trois modes d'accès:
- accès séquentiel.
- accès direct.
- accès binaire.
Il s'agit là de la façon dont un fichier pourra être accédé. Un même fichier pourra être accédé en
séquentiel et en direct par exemple.

3.2. Accès séquentiel:

C'est généralement l'accès utilisé pour lire un fichier texte. Les lignes sont séparés par
Chr(13)+Chr(10) (CR-LF).

3.2.1. Ouverture d'un fichier en accès séquentiel:

Open nom_fic For {Input | Output | Append} As N°F
nom_fic : variable contenant le nom du fichier (avec le chemin
éventuellement) ou constante chaîne.
Input : accès en lecture.
Output : accès en écriture avec réinitialisation du fichier (si déjà existant).
Append : accès en écriture avec ajout à la suite des ligne déjà existantes dans le fichier.
N°F : Numéro logique associé au fichier (de 1 à 511)
(FreeFile permet de donner un N° disponible).
Open "C:\TEXT1.DOC" For Input As 1
(Ouverture pour lire le fichier TEXT1.DOC)
3.2.2. Lecture des données:
. Line Input #NF , Ligne$
(permet de lire la ligne courante et la mettre dans la chaîne Ligne$).
. Si la ligne est une fin de fichier alors la fonction EOF retourne la valeur True.

Exemple: lecture du fichier TEXT1.DOC et son affichage dans l'objet text (TEXT).

Sub LEC_AFF()
Dim Ligne As String, C As String
' Ouverture
Open "C:\TEXT1.DOC" For Input As 1
' lecture
Do While Not EOF(1)
Line Input #1 , Ligne
C=C+Ligne+Chr(13)+chr(10)
Loop
TEXT.text=C
End Sub

3.2.3. Ecriture des données:

 . Print #NF , Ligne$
(écriture d'une ligne dans le fichier de N° Nf)

3.3. Accès direct:

Dans ce mode d'accès le fichier est vu comme une suite d'enregistrements de longueur fixe. La structure
de l'enregistrement est define à l'aide de la directive Type.
Exemple:
Type TEMPL
Mat As Integer
Nom As String *25
Adr As String *30
Vil As String *10
Sal As Currency
End Type
3.3.1. Ouverture en accès direct:
Open Nom_fic For Random As NF Len=Len(enreg)
Dans ce mode d'accès, par défaut, on peut à la fois lire et écrire.
3.3.2. Lecture/Ecriture en accès direct:
Get NF, NumEnr , Enreg (lecture)
Put NF , NumEnr , Enreg (écriture)
Lecture/écriture de l'enregistrement de N° NumEnr dans la zone Enreg. NF est le N° logique du fichier.
(La numérotation des enregistrements se fait à partir de 1)
Dim Empl As Templ
Open "C:\EMPL.DAT" For Random As 1 Len= Len(EMpl)
Get 1, 48 , Empl
' affichage emplyé de l'enregistrement N° 48
' Modification éventuelle
Put 1 , 48 , Empl
3.4. Accès binaire:
Dans ce mode d'accès, VB considère le fichier comme étant une suite d'octets sans structure
particulière.

3.4.1. Ouverture en accès binaire:

Open Nom_fic For Binarry As NF
3.4.2 Lecture/écriture accès binaire:
On utilise en accès binaire également les instructions Get et Put. Le N° d'enregistrement de
l'accès direct est remplacé par le N° d'octet (compté de 1).

Dim Zone As String *20

Open "C:\M ONFIC" For Binarry As 1
Get 1, 40 , Zone
' Lecture de 20 octets à partir de l'octet N° 40 (20 car c'est la taille de Zone).
.........
' On peut également utiliser l'instruction Input
Seek 1 , 40
Zone=Input(20 , 1)
3.5. Fermeture de fichier:
Close NF1, NF2, .... 'Fermeture des fichiers NF1, NF2, ...
Close ' Fermeture de tous les fichiers.

Les feuilles de travail.

1. Définition:
 - Une feuille est un objet qui constitue un cadre pour accueillir les autres objets de l'application (textes,
commandes, étiquettes, listes, ...).
- C'est le moyen privilégié pour réaliser le dialogue avec l'utilisateur. Cela se fait à partir de la première
feuille "dite principale". D'autres feuilles "dites secondaires" pourront être sollicitées.
- Dès que l'on lance VB, une première feuille est automatiquement créée.
- La feuille est un objet dont l'apparence est contrôlée par le biais de propriétés et des événements.
2. Principales propriétés d'une feuille:
2.1. Identification:
- Name : C'est le nom de la feuille. Il permet de distinguer un une feuille parmi plusieurs faisant partie
de l'application (exemple F1).
- Caption: permet d'afficher un titre significatif dans la barre de titre de la feuille.
2.2. Elément système:
- BorderStyle: permet de spécifier le type de bordure
0= pas de bordure
1= bordure simple
2= bordure permettant le changement de taille (défaut)
3= bordure à double filet (fixe)
4= bordure pour boîte à outils (fixe)
5= bordure pour boîte à outils avec changement de taille.
-ControlBox : permet de spécifier l'existence du menu système ou non.
= False : pas de menu système.
= True : menu système apparent (défaut)
- MinButton : permet de spécifier l'existence du bouton de réduction (=Tue ) ou non (=False).
- MaxButton : permet de spécifier l'existence du bouton
d'agrandissement (=Tue ) ou non (=False).
- Icon : permet de spécifier l'icône à associer à la feuille.
(On peut modifier (ou spécifier) l'icône de façon
dynamique (lors de l'exécution) en exécutant l'instruction du type suivant:
F1.Icon = LoadPicture("C:\VB\icons\office\files01.ico")
2.3. Comment déplacer une feuille?
- Emploi des conventions standards de Windows:
- déplacement (cliquer sur la barre de titre).
- changer les dimensions (si border style =2 ou 5).
- bouton de réduction et d'agrandissement.
(Chaque fois que la feuille a changé de taille l'événement "Resize" est généré ce qui permettra de
modifier le contenu de la fenêtre par exemple).

Sub Form_Resize()
....
End Sub
- Coordonnés et taille d'une fenêtre
- Coordonnés: celle du coin haut à gauche par rapport au coin de
l'écran.
Left et Top exprime en nombre de twips (1440 twips par pouce~567 twips par centimètre).

- taille de la feuille: largeur (Width), hauteur (Height) exprimés en nombre de twips.

Exemple: Le code suivant permet d'afficher, lors de l'exécution, la feuille dans le quart haut et gauche
de l'écran.
F1.Left = 0
F1.Top = 0
F1.Width = Screen.Width/2
F1.Heigth = Screen.Heigth/2
ou (mieux)
F1.Move 0 , 0 , Screen.Width/2 , Screen.Heigth/2
3. Application multifeuilles:
- Au départ une application n'a qu'une feuille. On peut en ajouter autant que l'on voudra. On procédera
de la façon suivante:
+ Cliquer sur l'icône nouvelle feuille de la barre d'outils
+ ou sélectionner au niveau menu Insertion/Feuille.
- Chaque feuille ajoutée on lui associe les propriétés voulues en sollicitant la fenêtre des propriétés (F4).

3.1. Visibilité des feuilles:

- Seule la fenêtre principale est visible au départ. L'affichage d'une fenêtre secondaire se fera, en
principe, à la suite d'un événement.
Les méthodes ou instructions suivantes sont à utiliser:
+ Load nom_feuille
Chargement de la feuille en mémoire sans affichage.
Load F2
+ Show
Rend visible une fenêtre (si cette fenêtre n'est pas déjà chargée il y a appel implicite à Load).
F2.Show
+ Hide
Rend invisible un fenêtre sans la décharger de la mémoire.
F2.Hide
+ Unload
Décharge une feuille de la mémoire et la cache (Hide) si elle est visible.
Unload F2

3.2. La feuille initiale:

Parmi toutes les feuilles il faut spécifier celle qui va apparaître la première. Pour cela il faut opérer
comme suit:
- niveau menu: Outils/Options
- sélectionner de l'onglet Projet
- sélectionner dans la liste combinée la feuille de démarrage.
4. Les feuilles prédéfinies:
Il y a essentiellement deux feuilles prédéfinies prêtes à l'emploi; qu'on peut utiliser:
+ Boite de saisie (InputBox) qui permet la saisie d'une donnée.
+ Boite de message (MsgBox) qui permet d'afficher un message et attendre éventuellement une réponse.

4.1. Boite de saisie: InputBox

C'est une fonction qui affiche une fenêtre ayant :
- titre : Titre
- un texte affiché (prompt): texte
- une zone de saisie qui contient une valeur par défaut (vdefaut)
- un bouton "OK" qui permet de valider la saisie
- un bouton "Annuler" qui fait retourner la chaîne vide.
InputBox(texte, titre, Vdefaut)
Cette fonction retourne:
- la valeur saisie si OK
- la chaîne vide si Annuler
Exemple
Dim Monfic As String
MonFic=InputBox("entrez le nom du fichier", "exemple","C:\TEXT1.DOC")
If MonFic<>"" then
'traitement du fichier
....
End if
4.2. Boite message: MsgBox
C'est le moyen adéquat pour afficher un message à l'utilisateur. La fonction MsgBox affiche une fenêtre
ayant:
- un titre : titre
- un message : message
- une icône accompagnant le message (Stop, ! , ?,...)
- un, deux ou trois boutons (OK, Annuler, abandon,...)
Tous ces éléments sont spécifiés de la façon suivante:
MsgBox(Message , valeur|expression , titre)
La valeur ou l'expression respecte les conventions suivantes:

Choix des boutons.

valeur constante VB signification
0 VbOkOnly Bouton OK seul
1 VbOkCancel Boutons OK et Annuler
2 VbAbortRetryIgnore Boutons Abandonner, Réessayer et Ignorer
3 VbYesnoCancel Boutons Oui, Non et Annuler
4 VbYesNo Boutons Oui et Non
5 VbRetryCancel Boutons Réessayer et Annuler

Choix du bouton par défaut en sollicitant Entrée.

Valeur Cste VB Signification
0 VbDefaultButton1 le premier
256 VbdefaultButton2 le deuxième
512 VbDefaultButton3 le troisième

Choix de l'icône à afficher.

Valeur Cste VB Signification
0 Aucune Icône
16 VbCritical icône Stop
32 VbQuestion icône ?
48 VbExclamation icône !
64 VbInformation icône "i"
La fonction MsgBox retourne une valeur qui indique le bouton qui a été
sélectionné par l'utilisateur. Cette valeur est conforme à la convention suivante:
Valeur Cte VB Signification
1 VbOk Bouton OK
2 VbCancel Bouton Annuler
3 VbAbort Bouton Abandonner
4 VbRetry Bouton Réessayer
5 VbIgnore Bouton Ignorer
6 VbYes Bouton Oui
7 VbNo Bouton Non.
Exemple:
Dim Rest As Integer
Ret=MsgBox("Voulez-vous réellement supprimer l'employé?" , VbYesNo +
VbDefaultButton2 + VbCritical,"Gestion du Personnel")
If Ret=VbYes Then
' traitement de Suppresion de l'employé
End If
5. Autres propriétés, événement et méthodes:
5.1 Propriétés:
- Appearance : les contrôles dans le feuille sont dessinés en 3 dimensions ou non.
=1 : effet 3D
=0 : pas d'effet
 - Visible : état visible (True) et False si non
- Couleur et caractères:
BackColor : couleur de fond
ForeColor : couleur des caractères et des traits
FontName : police des caractères
FontSize : taille des caractères (valeur)
FontBold : caractères gras (True, False)
FontItalic : caractères en italic (True, False)
FontStrikethru : caractères barrés (True, False)
FontUnderline : caractères soulignés (True, False)
FontTransparnet : fond des caractères transparents (True, False)
- Icone, Image, Picture:
Icon : Fichier Icône à associer à la feuille.
Image : Image du fond de la feuille : Bitmap
Picture : Dessin du fond : Bitmap, Icône, Métafichier.
- Forme du pointeur de la souris:
Mousepointer : 0 (défaut) à 15, (11=Sablier), ou 99
MouseIcon : image utilisé (Mousepointer=99)
- chaînes de caractères associées à la feuille:
Tag : texte
5.2 Les événements:
Parmi les événements gérés pour les feuilles on trouve en particulier ce qui suit:
- Click
- DblClick
- Activate : la feuille devient active
- Deactivate : la feuille devient inactive
- Load : chargement de la feuille
- Unload : déchargement de la feuille
- Resize : modification des dimensions de la feuille
Remarque: Load est parmi les événements les plus utilisés: On l'utilise, en particulier, pour effectuer le
traitement préleminaire (Prologue) de l'application: chargement de table, initialisation, ...

5.3 Les méthodes:

- Show : rendre visible la feuille.
- Hide : rendre invisible la feuille.
- Print : affiche un texte F1.Print "Bonjour".
- Cls : efface le contenu de la feuille.
- PrintForm : imprime la feuille.
- Move : déplace et/ou redimensionne la feuille.

Les Contrôles
1. Definition:
- C’est un objet élémentaire utilisé pour réaliser une interaction avec l’utilisateur (affichage, saisie).
- Un contrôle est obligatoirement placé sur une fauille.
- Un contrôle et caractérisé par des proprietés (couleur, texte affiché, ...).
- On associe à un contrôle des événements qui provoquent l’exécution du code prévu.
- Un contrôle possède des méthodes qui effectuent certaines tâches particulières.
- Certains aspects sont communs à tous les contrôles, d’autres sont spécifique.

2. Types de contrôles:
Ils sont accéssibles à partir de la boîte à outils en phase de conception: champs de saisie (Textbox),;
étiquette (Label); boutons (commandButton, chekBox, OptionButton); les listes (ListBox, COmboBox,
DriveListBox, DirListBox, FileListBox); les barres de défilement (HScrollBar, VScrollBar); le cadre (Frame);
les dessins (PictureBOx, Image, Shape, Line); la minuterie (Timer); le contrôle données (Data); contrôles
personnalisés (CommonDialog, OLE, Grid); ...

3. Caracéristiques communes:
- Name : identification de l'objet (ex: MonCtl)
MonCtl.BackColor : couleur de fond du contrôle
MonCtl_click sera le nom de la procédure événement sollicité si on clique sur la contrôle.
- Caption : texte visible sur le contrôle
- Appearance : effet 3D ou non
- BackColor : couleur de fond du contrôle
- ForColor : couleur des caractères du texte de caption
- Visible : permet de cacher ou rendre visible le contrôle
- Enabled : True (le contrôle est sensible), False (le contrôle est grisé).

Si le contrôle a le focus (ce que l'on peut provoquer par la méthode Setfocus) alors il pourra recevoir des
événements qui peuvent provenir de la souris ou du clavier :
- prevenance de la souris:
Click, Dblclick, MouseDown, MouseMove, MouseUp
- prevenance du clavier:
KeyDown, KeyPress, KeyUp
- La propriété Parent renvoie sur la feuille où se trouve le contrôle. On pourra par ce biais accéder aux
propriétés de la feuille sans en connaître le nom.
Ex: MonCtl.Parent.Caption="Un titre"
- TabIndex : valeur définissant l'ordre de parcours des contrôles dans la feuille quand on sollicite la
touche tabulation (c'est intéressant pour les champs de saisie d'une forme).
- TabStop : indique que le focus ne peut pas avoir lieu par le jeu de tabulation.

4. Accès à une propriété d'un contrôle:

4.1 Contrôle appartenant à la feuille:
nom_controle.proprieté=valeur
MonCtl.Caption="Exécution"
4.2 Contrôle appartenant à une autre feuille:
nom_feuille.nom_controle.proprieté=valeur
F1.MonCtl.Caption="Quitter"

5. Contenant d'un contrôle:

- Un contrôle soppose toujours un contenant qui peut être:
+ Une feuille
+ Un cadre
+ Une image
- Comment mettre un contrôle dans un contenant?
1- mettre le focus sur le contenant
2- solliciter le dessin du contrôle
- Conséquences liées aux contenants
+ Les coordonnées du contrôles sont par rapport au contenant
+ si le contenant est dépalcé le contrôle est déplacé aussi
+ Si le contenant devient invisible le contrôle aussi
- Le dessin du contrôle est restreint à la surface du contenat. Cela peut conduire à la troncature (vision d'un
morceau du contrôle seulement) (On appelle cela le clipping).

6. Groupe de contrôles:
Un groupe de contrôles est un ensemble de contrôles, en nombre variable qui portent le même nom
(Name) et les mêmes procedures événements. On peut comparer le groupe à une table de contrôles où la
référence à un élément se fait moyennant un indice. Ce dernier représente pour les éléments du groupe la
proprieté Index..
6.1 Définition d'un groupe:
Il faut en phase de conception, créer un contrôle avec la propriété Index positionnée à une
valeur numérique.
D'autres éléments du groupe peuvent être crées, il suffit de donner à chacun le même nom mais une
valeur différente à la propriété Index.
 6.2 Retrait d'un élément du groupe:
- Changer son nom (si d'autres existent avec le même nom)
- Remettre la proprieté Index à vide.
6.3 Procédures événement du groupe:
Si le nom des contrôles appartenant au groupe est MonCtlG alors la procédure répondant à un
click sera
Sub MonCtlG_Click(Index As Integer)
....
MonCtlG(Index).Caption="Contrôle"+Str$(Index)
....
End Sub
Cette procédure traite l'événement Click relatif au contrôle dont le numéro (valeur Index) est passé en
argument. Dans cette exemple on fait afficher sur le contrôle Contrôe1, Contrôle2, ... selon la valeur de Index.
Dans les traitements, l'accès au contrôle MonCtlG N° 9 se fait en utilisant 9 comme indice de la façon suivante :
MonCtlG(9).Caption="Un texte".
6.4 Création dynamique d'un élément de groupe:
La création pendant l'éxécution se fait par l'instruction Load comme suit:Load MonCtlG(11)
- L'index utilisé (ici 11) ne doit pas exister déjà.
- Les proprietés du contrôle ainsi crée ont les mêmes valeurs que celui crée précédement. Il faut donc
changer les proprietés qui doivent le distinguer (Caption en particulier).
6.5 Retrait dynamique d'un élément de groupe:
Le retrait d'un élément du groupe se fait par l'instruction Unload comme suit:Unload
MonCtlG(9).

Le cadre
1. Utilisation:
Le cadre (Frame) est utilisé:
- comme contenant de boutons d'options.
- pour regrouper visuellement des contrôles ayant des affinités
(aspect esthétique).
Il se présente sous forme d'un rectangle avec un texte (valeur de Caption ) écrit sur le bord supérieur.
2. Proprietés particulières:
- Caption : pour afficher un texte associé au cadre.
- BackColor, ForColor.
- FontName,....
- MousePointer.
3. Evénements:
- Click, DblClick
4. Méthodes:
- Move : déplacement du cadre
MonCadre.Move 160,170
- Refresh : force le dessin du contrôle
MonCadre.Refresh

L'étiquette
1. Utilisation:
Le contrôle étiquette (Label) est utilisé pour afficher du texte:
- Libellé de champ de saisie
- Titre, sous_titre, ...
- Messages affichés pendant l'éxécution.
2. Proprietés particulières:
- Caption: Contient le texte à afficher qui ne poura pas être modifié par l'utlisateur.
Si mon contrôle s'appelle lblCtl alors on pourra avoir:
1) lblCtl.Caption="message à afficher"
2) lblCtl.Caption="1ere ligne message"+Chr(13)+"2eme ligne message".
(- affichage sur 2 lignes: Chr(13) indique le changment de ligne.
- la hauteur du contrôle doit être suffisant pour pemettre l'affichage des deux lignes).
Remarque : Le "&" dans le texte de caption indique que la lettre suivante (B) est une touche d'accès direct (Alt-
B) qui a pour effet de mettre le focus sur le contrôle qui suit cette étiquette. La lettre après le "&" sera soulignée
pour être mise en évidence.
 - Autosize : permet au conlrôle étiquette de s'adapter pour afficher tout le texte de caption.
- Alignement : permet d'aligner le texte
= VbLeftJustify (ou 0): alignement à gauche
= VbRightJustify (ou 1): alignement à droite
= Vbcenter (ou 2): texte centré
- BorderStyle: permet de mettre (ou ne pas mettre) de cadre autour du contrôle.
= VbFixedSingle (ou 1): mettre un cadre (ressemblance à un champ de saisie)
= VbBSNone (ou 0): pas decadre (defaut).
- BackStyle: permet yne écriture transparente ou opaque
= VbTransparent (ou 0): écriture sans cacher ce qui est derière le cadre de contrôle.
= VbOpaque (ou 1): le fond du contrôle est rempli avec la couleur de Backcolor.
- Visible: permet de cacher le texte ou le rendre visible (True) en fonction de situations.
- Proprietés de visualisation : FontName, FontSize,..., BackColor, ForeColor,...
3. Evénements courants:
-Click et Dblclick
- Change (à chaque modification de la valeur de Caption)
4. Méthodes courantes: Move
lblCtl.move 110, 170
fait déplacer le texte à un autre endroit.

Le champ de saisie
1. Utilisation:
Le champ de saisie est un véritable éditeur de texte. Le programme NOTPAD (éditeur de texte) fourni
avec windows est essentiellement un champ de saisie (multiligne).
On a recourt aux champs de saisie pour:
- Saisir des champs du type nom, salaire, ...(monoligne)
- Saisir des textes complets (taille<=64 Ko) (multiligne)
2. Point d'insertion:
. La saisie de ce qui est tapé au clavier se fait à partir d'un point d'insertion dans le champ (champ
contenant déjà des caractères). Ce point est matérialisé par la présence à cet endroit d'un curseur (barre verticale)
clignotant.
. On peut changer le point d'insertion en cliquant à l'endroit voulu.
. Toutes les conventions de saisie standard au niveau de Windows sont respectées (flèches de
déplacement du point d'insertion, HOME et FIN (debut et fin de ligne) Ctl-HOME et Ctl-FIN (debut et fin de
texte), SUIV et PREC, BackSpace (effacer le caractères précédent), SUPPR (effacer le caractère suivant).
3. Sélection d'une partie de texte:
3.1 Caracteristiques:
- La partie du texte selectionné se caracterise par :
+ La position du caractère de début (SelStart)
+ La longueur de la partie selectionnée (SelLength)
+ La valeur de cette partie (SelText)
Remarque: si SelLength=0 alors il y a simplement un point d'insertion à la
position SelStart
- On utilise généralement le selection pour effectuer l'echange avec le presse papier (copier, coller, ...).
3.2 Comment effectuer la selection?
3.2.1 Par l'utilisateur:
. Cliquer avant le premier caractère et faire glisser la souris jusqu'à la position voulue en
gardant le bouton enfoncé.
Ou
. Amener le curseur juste avant le 1er caractère, appuyer et garder enfoncée la touche MAJ,
déplacer le curseur (touches de déplacament) jusqu'à l'endroit voulu.
3.2.2 Par programme:
Si mon texte s'appelle MonTexte alors on aura:
MonTexte.SelStart=12 (position depart)
MonTexte.SelLength=5 (longueur)
(SelLength <= 65535 pour un système 16 bits)
Remarque: Selection de tout le texte
MonTexte.SelStart=0
MonTexte.SelLength=65535
 3.3 Marque d'un texte selectionné:
- Le texte est en videoinversé
- Dès que le champ perd le focus la vidéoinversé disparait por
repparaitre lorsque le champ retrouve le focus.
- On pourra demander à VB de faire en sorte que la vidéoinversé reste même lorsque le champ
perd le focus. Cela se afit par:
MonTexte.HideSelection=False

3.4 Emploi de Couper-Coller:

- Copier de la selection dans le peresse-papier
. Solliciter : CTRL+C
- Coller le contenu du presse-papier
. Solliciter : CTRL+V
cela remplace la partie selectionnée ou s'insère à partir du point d'insertion.
- Couper et Copier une selection
. Solliciter : CTRL+X
Remarque: On peut présenter plus loin (objet Clipboard) comment s'y prendre au niveau
programmation.
3.5 Monoligne et multiligne:
Le champ de saisie sera utilisé pour:
+ La saisie de champ "factuel" généralement de longueur fixée et sur une ligne. Pour cela on
utilisera:
MonTexte.Multiligne=False (monoligne)
MonTexte.MaxLength=valeur
si valeur # 0 on ne pourra pas saisir plus de "valeur" caractères.
+ La saiosie du texte complet (champ type memo).
Pour cela on utilisera:
MonTexte.Multiline=True (multiligne)
MonTexte.MaxLength=0
Et généralement on demandera la mise en place d'ascenseurs, car le texte ne pourra pas être
visualisé totalement. Cela se fera par:
MonTexte.ScollBars
= Vbhorizontal (ou 1)
= VbVertical (ou 2) (le plus courant)
= VbSBNone (ou 0) (Pas d'ascanceur)
= VbBoth (ou 3) (les deux)

3.6 Accès au texte saisie:

L'accès au texte saisie se fait en utilisant la proprieté Text (une des rares qui ne porte pas le
nom Caption).
Dim CH As string
CH=MonTexte.Text
' Modification de CH
MonTexte.Text=CH
3.7 Saisie de mots de apsse:
Les mots de passe ne doivent pas s'afficher quand on les saisit. Pour permettre cela on utlisera
la proprieté PasswordChar/
MonTexte.PasswordChar="*"
'chaque caractère tapé sera affiché par "*"
On reprend une saisie normale comme suit:
MonTexte.PasswordChar="" ' chaîne vide
' chaque caractère tapé sera affiché en clair

4. Validation de la saisie:
On présentera ici les événements générés par un champ de saisie susceptible d'être exploiter pour
contrôler les données saisies.
- Keypress: est généré dès qu'on appuie sur une touche. Le code ANSI de la touche ets transmis comme
argument (le caractère n'est pas encore arrivé dans le champ).
Sub MonTexte_Keypress(CodeTouche As Integer)
 End Sub
- Change: est généré lorsque le champ de saisie a traité la touche et affiché la modification
correspondante.
Sub MonTexte_Change()

End Sub
- GotFocus: est généré dès qu'on entre dans le champ (par un click ou par tabulation).
- LosFocus: est généré lorsqu'on quitte la champ (on pourra à nouveau procéder à un contrôle et
en cas d'erreur obliger le focus à rester sur le champ par emploi de SetFocus).
Exemple: Supposons un champ N° CNSS (NCNSS) qui ne doit comporter que des chiffres. Voici ce
Qu'on pourra envisager pour s'assurer de la vraissemblancede la donnée saisie.

Les Boutons

1- Utilisation

Il y a 3 types de boutons :

- le bouton de commande : permet la saisie d’une commande utilisateur

- la case à cocher : permet la saisie d‘une valeur binaire ( du type oui/non) avec parfois un 3
ème état.
- les boutons d’options: permet la saisie d’une option parmi celles possibles.

Ces boutons sont activés par :

- click du bouton gauche de la souris

- barre espace si le bouton à le focus

L’état du bouton est représenté par la propriété value.

2- Bouton de commande

Contrairement aux autres contrôles il ne dispose pas de propriétés ForeColor et BackColor ( par défaut
c'est celle définie dans le panneau de configuration ou dans le fichier WIN.INI)

2.1- Propriétés spécifiques

- Default:
Si True :cela veut dire que la touche ENTER est équivalente à un click si toutefois le bouton a
la focus.
- Cancel:
- Si True :cela veut dire que la touche ECSape est équivalente à un click.

2.2- Comportement

+ Lorsque le click est généré :

- le bouton commande est enfoncé
- la propriété value est à True

+ Si par programme on met la propriété value à true alors l’événement click est généré ( et donc
l'exécution de la procédure correspondante ).

3- La case à cocher.

On l’utilise pour la saisie d’une valeur booléenne à chaque click de l’utilisateur le bouton passe de
l’état coché à l’état non coché , et inversement .

L’état caché est représenté par :

 - Une croix dans le rectangle du contrôle
- Propriété Value = vbChecked (cte = 1)

L’état non caché est représenté par :

- L’absence de croix dans le rectangle.
- Value = vbUnchecked ( cte = 0)

L’état grise est représenté par :

- L'intérieur du contrôle est grisé
- Value = vbGrayed ( cte = 2)
Cet état veut dire qu’il y a indétermination de la valeur. Cela se justifie par le fait que l’état
coché ou non peut ne pas avoir de sens dans certains contextes.

Remarque

Il ne faut pas confondre l'état grisé qui est une valeur particulière de l’état du bouton (3 éme état ) avec
l’état inopérant commun à beaucoup de contrôles et qui veut dire que le bouton ne peut pas être sollicité par
l’utilisateur.

3.1 Comportement

A chaque changement de la propriété Value un événement click est généré. On pourra l’ignorer car il
est redondant avec la valeur de ne alue.

1- Le bouton d’options

Ce type de bouton n’est en principe pas solitaire. Il

fait partie d’un groupe de boutons d’option. Le principe est que dés qu'une option est sélectionnée toutes les
autres sont déselectionnées.

Il faut donc que tous les boutons d’option soit placés dans un même contenant (généralement un cadre )
appartiennant à un même groupe .

4.1- Comment placer les bouton d’option ?

On peut procédera comme suit:

1. Mettre en place un cadre
- sélectionner l’icône cadre
- dessiner le cadre
- lui donner un titre on mnémonique
( Caption )
2. Sélectionner l’icône bouton d’option
3. Cliquer à l’intérieur du cadre et
positionner le bouton.
4. Recommencer de la même façon pour les
autres boutons à option .
Etat des boutons à option
L’état d’un bouton est indiqué par la propriété value (True ou false)
Dans un groupe à option un bouton au plus est à True ( c'est à dire sélectionné ) ; les autres sont
automatiquement à False.
Si par programme on met à True un boutons les autres ( Ceux du groupe ) sont remis à False automatiquement.
Comment déterminer l’option choisie?
Il faut tester la propriété value des boutons.
Le bouton pour lequel value est à True correspond à l’options choisie. Ce la se fait par des If en cas jusqu'à
rencontrer la valeur True if
On pourra également mémoriser, dans une variable globale, le numéro du bouton, à l’occasion de chaque
sélection ( exploiter l’événement click qui est généré ) . if
4.4- Création des boutons en tant que groupe
- Au lieu de créer différents boutons avec différents nom ( un seul nom) en positionnant la propriété Index à
une valeur ( 0 pour le premier par exemple).
- On peut réaliser cela en copiant le premier dans le presse - papier ( Ctrl+C ) puis on collant plusieurs fois dans
le contenant en question ( cadre ) en utilisant Ctrl+V VB incrémente alors automatiquement la valeur de la
propriété Index.
Pour déterminer l’option choisi + il suffit d’une boucle .
' Détermination de l’option : cas d’un groupe .
Sub OPT - click ( Index As Integer)
NUMOPT = Index.
End Sub.

Sub OPTG ()
Dim I As Integer
For I=0 . to 2 3 option
if OPT ( I ) . Value then
Etiq. Caption = ‘’ option ‘’ + OPT (I) . Caption
Exit for
Next end if
End Sub

LES LISTES
1- Utilisation
Les listes permettent à l’utilisateur de sélectionner un élément parmi une liste d’éléments textuels dont
le nombre peut varier en cours d’exécution.
2- Types de liste
Il y à deux types de listes générales et trois types de listes spécialisées.
Liste générales
 La liste simple ( liste Box ) : C’est une liste simple d'éléments textuels.
 La liste combinée ( ComboBox) : c’est l'association d’une liste simple et d’un champ de
saisie
Liste spécialisées
- La liste d’unité disques ( liste de lecteurs, Drive liste Box ) : c’est une liste spécialisée dans
l’affichage des unités disque du système (a, e: )
- La liste de répertoires ( DirlistBox ) : c’est une liste spécialisée dans l’affichage des sous
répertoires du répertoire courant.
- La liste de fichiers ( File liste Box ) : c’est une liste spécialisée dans l’affichage des fichier du
répertoire courant dans le lecteur courant.
1- Comportement
L’événement click indique la sélection d’un élément de la liste.
Dans le programme nous avons accès aux propriétés suivantes :
Liste count : indique le nombre d’élément dans la liste
Liste : représente l’équivalent d’un tableau dont les éléments sont les éléments de la liste
Liste (0 To ListeCount - 1 )
Liste Index : indique l’indice de l’élément sélectionné par le click. La valeur -1 informe qu’aucun
élément n’est sélectionné.
Texte : pour les liste simple et d »roulante, contient l’élément sélectionné.
Maliste . texte = Maliste . Liste ( Liste Index)
D’autre événements sont possibles tels que : GotFocus, LostFocus, KeyDown et KeyUp.
Exemple :
 Une liste Maliste affiche une liste de noms
 L’utilisateur sélectionne un nom
 Puis il appuie sur le bouton de commande OK
 La procédure affiche le nom sélectionné dans
 L’objet étiquette etiq accompagné du nombre de personne
Etiq. Caption = Maliste . texte + Vstr$ ( Maliste . liste count ) + ou ‘’ personnes’’
Etiq. Coption = Maliste . list (Maliste . list Index ) + .......
End Sud .
1. Liste Simple.
 c’est un contrôle rectangulaire contenant une liste de chaîne de caractères
  Un ascenseur vertical apparaît à droite p les éléments ne peuvent pas être visibles tous à la fois
4.1 Ascenseur horizontal : Columns
 On peut avoir un ascenseur horizontal pour cela il faut donner une valeur non nulle à la propriété
Columns
Columns = 0 Pas ascenseur et une seul colonne.
Columns = 1 Ascenseur et une colonne
Columns = 2 Ascenseur et deux colonnes, etc......
4.2 Sélection simple ou multiple : Multiselect
Par défaut un seul élément pourra être sélectionné à la fois . Mais il est possible de permettre la
sélection de plusieurs éléments à la fois (tous les éléments sur lesquels on clique) . pour spécifier cet aspect des
chose on positionne la propriété Multiselect comme suit :
Multiselect =
0 : Sélection simple.
1 : Sélection multiple. Chaque click sélectionne ou déselectionne l’élément.
2 : sélection étendue. On l’obtient en maintenant la touche Ctrl ou Maj lors du click pour
étendre la sélection.
4.1 Comment savoir si élément est sélectionné ?
Dans le cas ou Multiselect est égal à 1 ou 2 la propriété selected pourra être utilisé pour savoir si un
élément est sélectionné ou non.
Maliste. Liste (I) . Selected
= True : l'élément d’indice I est sélectionné.
= False : il n’est pas sélectionné.
Exemple :
 Du dispose d’une liste Maliste de noms et d’un contrôle texte multiligne ( Montexte)
 Les éléments sélectionnes seront affichées dans la zone texte à réunion d’un nom par ligne à la suite
du click sur le contrôle commande OK
Sub Ok_click()
Dim I As Integer
Dim RLIGNE As String
RLIGNE=Chr(13)+ Chr(10)
Montexte.text=""
For I=1 to Malist.Listcount-1
if Malist.List(I).Selected then
Montexte.text=Malist.List(I)+RLIGNE
End if
End Sub
4.4- Tri des éléments de la liste: Sorted
La propriété Sorted de la liste indique (si True) que les éléments qu'elle contient doivent être triés.
Si Sorted=True alors chaque ajout d'un éléments à la liste est inséré à sa place dans l'ordre alphabétique
croissant; à moins qu'on ait demandé à le placer explicitement à un endroit déterminé (ce qu'il faut éviter si on
utilise Sorted).

4.5- Ajout d'un élément à une liste:

L'ajout d'un élément à une liste se fait en utilisant la méthode AddItem

nom-Liste.AddItem élément-à-ajouter

Exemple:
' Ajout d'un nom saisie dans la zone texte NOM dans la liste Maliste à la suite ' ' d'un clic sur le bouton
de commande AJOUT
Sub AJOUT_Click()
Maliste.additem NOM.text
' le nom est ajouté à la fin de la liste si Sorted=False et l'endroit voulu si 'Sorted=True
End Sub

On peut également spécifier l'endroit où placer l'élément en terme d'indice du tableau liste:
Exemple:
Maliste.Additem "Brahim" , 2
Ou
 Maliste.List(2)="Brahim"
fait placer "Brahim" à l'indice 2 de la liste dont le premier élément a pour indice 0. Il faut bien entendu
qu'au moins les éléments précédents existent.
Maliste.List(Maliste.ListCOunt)= "Brahim"
fait placer "Brahim" en fin de liste.
Remarque:
En phase de création, on peut remplir la liste en sollicitant la propriété List ce qui fait apparaître un
champ de saisie multiligne pour saisir les éléments de la liste à raison d'un élément par ligne. Le passage à la
ligne suivante se fait par:
- Clic sur la nouvelle ligne
- Ctrl+ENTREE
ENTREE seul valide la saisie effectuée.
4.6- Suppression d'un élément de la liste:
La suppression d'un élément de la liste se fait en utilisant la méthode RemoveItem:

nom-liste.RemoveItem indice-de-élément

Exemple:
Maliste.RemoveItem 2
fait disparaître de la liste l'élément d'indice 2 (le 3eme de la liste).

La suppression de tous les éléments de la liste se fait en utilisant la méthode Clear :

nom-liste.Clear

Exemple:
Maliste.Clear
fait nettoyer Maliste

4.7- Utilisation du double Clic:

Le double clic est généralement considéré comme étant l'équivalent du clic sur le bouton de validation
Ok.
Pour respecter cela on pourra prévoir ce qui suit :
Sub Maliste_dblClick()
Ok_Click
End Sub
On simule le clic sur le bouton Ok
Remarque:
Le double clic c'est en réalité deux clic qui se suivent. Donc:
- le 1er clic sera traité en tant que tel, la procédure événement correspondant sera sollicité si elle existe.
- le 2eme clic s'il arrive dans un laps de temps inférieur à une valeur (défini à l'aide du panneau de
configuration et stockée dans le fichier WIN.INI) alors l'événements DblClick est généré.

5. Liste Combinée: ComboBox

On l'appelle aussi liste modifiable. Elle comprend:
- une liste simple et
- un champ de saisie
Il existe 3 types de listes combinées définies par la propriété Style.

5.1- Liste Combinée déroulante: Style=0

Propriété Style = VbComboDropdown (Cte=0) c'est la valeur par défaut.
Apparence:
- la liste est normalement visible
- le champ de saisie avec à sa droite un bouton avec une flèche vers le bas qui suggère que si on veut
visualiser la liste il suffit de solliciter ce bouton.
On fait dérouler la liste de deux façons:
- en cliquant sur le bouton en question
- si le contrôle a le focus on appuie sur ALT+ (Alt et touche flèche vers le bas)
Le fait que la liste soit cachée économise l'espace sur l'écran. Cela dit, tout ce qui a été dit sur la liste
simple reste vraie pour la liste combinée ; sauf en ce qui concerne la propriété Text
 Ici Text représente le contenu du champ de saisie et non l'élément sélectionné qui demeure la propriété
List(ListIndex)
Si on saisit quelque chose dans le champ de saisie, ce que l'on peut savoir par l'événement Change qui
généré, il n'y a plus d'élément sélectionné (Listindex vaut -1) et Text contient ce qui a été saisi. On en fait alors
ce que l'on veut (ajout dans la liste, argument de recherche ailleurs,...).
Par programme, on peut changer la valeur du champ de saisie en positionnant la propriété Text.
L'événement DropDown pourra être utilisé avec profit. Il est généré lorsque la liste est sur le point d'être
déroulée; ce qui pourra être saisi comme occasion pour mettre à jour la liste avec son affichage.

5.2- Liste Combinée simple: Style=1

Propriété Style= VbComboSimple (Cte=1)
Elle se comporte comme la combinée déroulante. Sauf que:
- la liste est toujours visible
- le bouton pour faire dérouler n'a pas lieu d'être.

5.3- Liste Combinée sans saisie: Style=2

Propriété Style= VbComboDropDownList (Cte= 2)
Elle se comporte comme la liste combinée déroulante avec une liste invisible. Le champ de saisie n'est
utilisé que pour l'affichage et n'autorise donc pas la saisie.

6. Listes Spécialisées:
- Il s'agit des listes d'unités de disques, de repertoires et de fichiers.
- Ces trois listes sont généralement utilisées de façon conjointe.
- L'application ne peut pas, en principe, modifier le contenu de ces listes, en conséquences les propriétés
List et ListCount ne sont accessibles qu'en lecture.
- ListIndex peut être modifié ce qui permet le changement de la sélection.

6.1- Liste unités de disques:

- C'est une liste combinée déroulante sans saisie
- Elle contient la liste des unités disque du système.
- Elle est remplie par V.B
- La propriété Drive permet de connaître ou de modifier la sélection.
Unité.Drive="c"
- En lecture la propriété Drive retourne une unité de disque telle que:
- "a: " (disquette)
- "c:[nom du volume] (disque dur)
- "m:\\serveur\nom" (unité réseau)
6.2- Liste des repertoires:
- Elle contient la liste des repertoires dans une unité disque
- La sélection peut se faire par double clic de façon à modifier le répertoire courant.
- Tous les repertoires, depuis la racine, sont affichés avec l'icône d'un répertoire ouvert; le répertoire
courant est grisé; et tous les sous repertoires apparaissent avec une icône de répertoire fermé.
- La propriété Path permet de connaître ou de modifier le répertoire courant (chemin absolu ou relatif)
Exemple: Repertoire.Path="C:"
ceci conduit à afficher le répertoire courant de l'unité "C:"
- La modification de la propriété Path génère un événement Change.
- Les indices du tableau List sont utilisés comme suit:
0 = 1er sous répertoire du répertoire courant
1 = 2eme sous répertoire du répertoire courant
etc....
- 1 : Répertoire courant (ouvert grisé)
- 2 : Répertoire immédiatement supérieur
etc....
6.3- Liste des fichiers:

- Elle contient la liste des fichiers d'un répertoire donné. Celui spécifié dans la propriété Path.
- Le fichier sélectionné se trouve dans FileName (chemin complet)
- FileName pourra être modifié pour spécifier une nouvelle unité disque, un nouveau répertoire ou un
nouveau fichier sélectionné. Ce changement peut générer les événements:
- PathChange
 - PatternChange
- DblClick
- La propriété Pattern permet de spécifier les fichiers à afficher par emploi d'un masque (utilisation
conventionnelle de * et ?)
Fichier.Path="C:\VB"
Fichier.Pattern="*.EXE ; *.COM ; *.BAT"
affichages des fichiers du répertoire VB des fichiers type EXE, COM ou BAT
- Autres propriétés booléennes jouant le rôle de filtre avant l'affichage
- Archive : fichier archive
- Hidden : fichiers cachés
- Normal : fichiers normaux
- ReadOnly : fichiers accessibles en lecture seule
- System : fichiers systèmes
- Si on modifie la propriété Path ou FileName un événement PathChange est généré.
- Si on modifie Pattern ou FilName (modèle de fichier) un événement PatternChange est généré.
- Une liste de fichier peut être à sélection multiple il suffit de spécifier la valeur de MultiSelected
Exemple:
On utilise les listes suivantes:
Unité : DriveListBox (unités disque)
Repertoire : DirListBox (repertoires)
Fichier : FileListBox (fichiers)
Le lien à faire entre les trois listes peut se faire comme suit:

Sub Unité_Change()
Repertoire.Path=Unité.Drive
End Sub

Sub Reprtoire_Change()
Fichier.FileName=Repertoire..Path
End Sub

Sub Fichier_Click()
' le fichier selectionné est identifié par
' Fichier.Path +"\" + Fichier.FileName
End Sub
 EMPLOI DES MENUS

1. Considérations générales

Il n’est pas nécessaire de justifier l’emploi des menus. Pour s’en convaincre il suffit de considérer les
applications sous Windows pour constater que les menus sont présents partout ; même si cela fait parfois double
emploi avec des boutons de commandes pour faciliter l’accès à des fonctionnalités fréquemment demandées.

La fenêtre principale des applications possède en général une barre de menu. La sélection d’un élément
de menu fait normalement apparaître un sous menu déroulant; qui peut conduire de nouveau à un autre sous
menu jusqu’à atteindre l’élément final qui correspond à la fonctionnalité recherchée ( cela génère un événement
du type Clic ( NomMenu_Click() ) qui sera utilisé pour mettre en oeuvre le traitement adéquat )

Chaque élément du menu reçoit un nom qui génère lorsqu’il est sollicité un événement Click. Si ce n’est
pas un élément final cela peut être utilisé pour faire éventuellement un traitement adéquat ( initialisation du sous
menu comte tenu du contexte de l’application ) avant de faire dérouler le sous menu.

2. Comment créer un menu ?

-Donner le focus à la feuille où l’on veut mettre en place le menu

- Solliciter la fonctionnalité ‘Créateur de menus’ :

+ niveau menu : Outils/ Créateur de menus

+ Bouton équivalent dans la barre d’outils

Cela fera afficher la fenêtre ‘Créateur de menus’ qui comprend en particulier les éléments suivants :

+ Un champ Caption : où l’on saisira le libellé de l’élément de menu courant qu’on est en train de traîter
( c’est l’équivalent de Caption de la plus part des Contrôles de VB)
Le signe ‘&’ dans le libellé signifie que la lettre qui suit représente une touche d’accès et apparaîtra
soulignée dans le menu.L’accès se fera en utilisant la combinaison de cette lettre avec la touche ALT ( par
exemple : &Fichier sera sollicité au niveau du clavier par ALT + F )

+ Un champ Name : où l’on saisira le nom de l’élément de menu courant qu’on est en train de traiter.
C’est l’équivalent de Name des Contrôles de VB; cela suit en conséquence les mêmes règles de
formation. Pour les distinguer on convient généralement de donner des noms qui commence par mnu ( pour
suggérer qu’il s’agit d’un élément de menu )

+ La liste Shortcut ( raccourci) autorise le choix d’une combinaison de touches dont l’action est
équivalente à la sélection de l’élément ( Exemple MAJ+ F12 )

+ Checked ( faux par défaut ) permet d’ajouter une marque devant l’élément pour indiquer qu’il est
sélectionné.

+ Enabled ( vrai par défaut ) permet de rendre l’élément grisé en vue d’interdire sa sélection

+ Visible ( vrai par défaut ) permet de rendre l’élément invisible. Dans ce cas, le menu est redessiné
complètement pour faire disparaitre complètement la trace de cette élément. Il réapparaîtra dès que la propriété
Visible devient Vrai.

Pour chaque élément, on saisit les propriétés précédentes.

Pour passer à l’élément suivant du menu, qui peut être horizontal ( menu ) ou vertical ( sous menu ) On
peut :

+ appuyer sur ENTREE

Ou
 + Cliquer sur le bouton Suivant

Pour indiquer que l’élément fait partie d’un menu ou d’un sous menu déterminé on utilisera les boutons
suivants :

: ( Flèche vers la droite ) placer dans le sous menu suivant

: ( Flèche vers la gauche ) placer dans le sous menu précédent

: ( Flèche vers le bas ) inverser l’élément et le précédent

: ( Flèche vers le bas ) inverser l’élément et le suivant

Le principe de création de sous menus est le décalage de l’écriture des éléments (décalage de 4
espaces )

Les boutons Insérer et supprimer permettront d’insérer n’importe où un nouvel élément de menu et de
supprimer tout élément préalablement sélectionné.
 Fonctions API

VB est doté d’une puissante caractéristique : la possibilité d’appeler des fonctions qui résident dans les
bibliothèques de liens dynamiques (DLL), et en particulier les fonctions API fournies par windows.
Pour utiliser les fonctions API, il suffit de les déclarer dans le code source puis de les appeler comme
n’importe quelle autre fonction de VB.
On peut accéder aux déclarations de fonctions API de VB dans le fichier Win32API.txt, qui existe dans
le dossier winapi.

Exemple : détermination du type du processeur

Le code ci-dessous utilise la fonction GestSystemInfo pour déterminer le type de CPU du système.
Comme on peut le constater en examinant la structure du type SYSTEM_INFO, cette fonction retourne plusieurs
autres informations utiles sur le système. Elle peut même retourner le nombre de processeurs sur le système
examiné.

Option explicit
Private Type SYSTEM_INFO
DwOemID As Long
DwPageSize As Long
LpMinimumApplicationAdress As Long
LpMaximumApplicationAdress As Long
dwActiveProcessorMask As Long
dwNumberOfProcessors As Long
dwProcessorType As Long
dwAllocationGranularity As Long
dwReserved As Long
End Type

Private Declare Sub GestSystemInfo Lib } Kernel32 } (lpSystemInfo AS SYSTEM_INFO)

Private Sub Form_Click()
Dim Sys As SYSTEM_INFO
GetSystemInfo Sys
Print } Type de Processeur : } ;  Sys.dwProcessorType
End Sub