La gestion des données créatives VB
La gestion des données créatives VB ressource de formation
...
- 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'applicat ion.
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 d imensions 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).
- 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 s elon 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 (Po sition de B) Left("ABCD", 2) : retourne "AB" Right("ABCD", 2) : retourne "CD"
Mid("ABCD", 2,1) : retourne "B" (à partir du 2 eme prendre 1 caractère). Mid(CH$, 2, 1)="X" : CH$="ABCD" "AXCD"
LTrim(" AB ") : r etourne "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.
- Généralités:
Emploi des fichiers
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 aliment er éventuellement une base de données.
- 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 lect eur 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 DOCUM ENT)
- 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
- 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 alo rs 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.
- Définition:
Les feuilles de travail.
- 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.
- 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 à asso cier à 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
- 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.
- 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, ...