Visual Basic - data.over-blog-kiwi.comdata.over-blog-kiwi.com/0/52/16/08/201305/ob_ff678a6db59993e1415e... · Visual Basic INSTITUT SUPERIEUR DU GENIE APPLIQUE Rue Ibn Habousse -

VViissuuaall BBaassiicc

INSTITUT SUPERIEUR DU GENIE APPLIQUE Rue Ibn Habousse - Hivernage 40000 MARREKECH - MAROC

Réalisé par : Mr Y.SAFSOUF Pour la classe : 3GI

Un CD comportant tous les TP avec des cours PDF en plus

Microsoft Visual Basic IGA Marrakech - 3GI

Mr Y. Safsouf 2/39

Table des matières

I. PRESENTATION DU LANGAGE VISUAL BASIC..................................................................................... 3 1. CONCEPTION DE L’INTERFACE GRAPHIQUE ................................................................................................................. 3 2. ECRITURE DU CODE SOURCE........................................................................................................................................ 3

II. DEMARRAGE DE VISUAL BASIC................................................................................................................... 3 1. L'INTERFACE DE TRAVAIL DE VISUAL BASIC .............................................................................................................. 3 2. STRUCTURE GENERALE : .............................................................................................................................................. 3 3. CONTROLES ET PROPRIETES......................................................................................................................................... 3 4. PROCEDURES EVENEMENTIELLES ................................................................................................................................. 3 5. COMPILATION ET INTERPRETATION ............................................................................................................................. 3 6. RACCOURCIS DE CLAVIER :.......................................................................................................................................... 3

III. PREMIERS ELEMENTS DU CODE ............................................................................................................. 3 1. VARIABLES..................................................................................................................................................................... 3

1.1 Déclaration, or not déclaration ? ............................................................................................................... 3 1.2 Déclaration explicite d'une variable.......................................................................................................... 3 1.3 Déclaration implicite d'une variable ......................................................................................................... 3 1.4 Portée des variables ....................................................................................................................................... 3 1.5 Variables indicées (Les Tableaux) ............................................................................................................. 3 1.6 Les constantes .................................................................................................................................................. 3

2. OPERATEURS ................................................................................................................................................................. 3 3. STRUCTURE DES TESTS : ............................................................................................................................................. 3

3.1 La structure : If...Then...Else...end If ..................................................................................................... 3 3.2 La structure Select Case...End Select...................................................................................................... 3

4. STRUCTURE DES BOUCLES : ........................................................................................................................................ 3 4.1 La structure For..Next.................................................................................................................................... 3 4.2 La structure For Each...Next ....................................................................................................................... 3 4.3 Les structures Do...Loop et While...Wend.............................................................................................. 3

IV. LA BOITE DE CONTROLES .......................................................................................................................... 3 1. LE COMMANDBUTTON (BOUTON DE COMMANDE) ..................................................................................................... 3 2. LE LABEL (ETIQUETTE) ................................................................................................................................................ 3 3. LA ZONE DE TEXTE (TEXTBOX) .................................................................................................................................. 3 4. LES CASES .................................................................................................................................................................... 3 5. LES LISTES .................................................................................................................................................................... 3 6. TROIS AUTRES CONTROLES (DRIVELISTBOX, DIRLISTBOX, FILELISTBOX) .......................................................... 3 7. UN CONTROLE PARTICULIER : LE TIMER ..................................................................................................................... 3 8. LES TABLEURS ............................................................................................................................................................... 3

V. AUTRES PROPRIETES DES CONTROLES.................................................................................................. 3 1. LOCALISATION DES CONTROLES .................................................................................................................................. 3 2. ACTIVATION DES CONTROLES ...................................................................................................................................... 3

VI. LES EVENEMENTS............................................................................................................................................ 3 1. EVENEMENTS FOCUS .................................................................................................................................................... 3 2. EVENEMENTS CLAVIER .................................................................................................................................................. 3 3. EVENEMENTS SOURIS ................................................................................................................................................... 3

VII. QUELQUES FONCTIONS ............................................................................................................................... 3


Mr Y. Safsouf 3/39

1. TRAITEMENT DES CHAINES : ....................................................................................................................................... 3 2. FONCTIONS NUMERIQUES : ......................................................................................................................................... 3 3. LA FONCTION MSGBOX ................................................................................................................................................ 3 4. LA BOITE DE DIALOGUE "INPUTBOX".......................................................................................................................... 3 5. GESTIONNAIRE D’ERREURS .......................................................................................................................................... 3

5.1 Erreur d'exécution ........................................................................................................................................... 3 5.2 Les propriétés de l’objet ERR ...................................................................................................................... 3

VIII. CREATION DES MENUS (CONTROLE) .................................................................................................. 3 1. CREATEUR DE MENUS, BOITE DE DIALOGUE ............................................................................................................... 3 2. OPTIONS DE LA BOITE DE DIALOGUE .......................................................................................................................... 3 3. ZONE DE LISTE DU MENU ............................................................................................................................................. 3 4. APPRENONS A REALISER DES BARRES DE MENU DANS NOTRE INTERFACE. .............................................................. 3

IX. GESTION DES FICHIERS ............................................................................................................................. 3 1. OUVRIR ET FERMER UN FICHIER................................................................................................................................... 3 2. LIRE UN FICHIER ........................................................................................................................................................... 3 3. ECRIRE DANS UN FICHIER ............................................................................................................................................ 3

X. ACCES AUX DONNEES (DATA CONTROLE / DAO / ADO) .............................................................. 3 1. UTILISATION DU CONTROLE DATA (DATA CONTROL)......................................................................................... 3 2. D.A.O (DATA ACCESS OBJECT) .......................................................................................................................... 3

2.1 – Déclaration de la base de données ....................................................................................................... 3 2.2 – Déclaration des jeux d'enregistrements ou recordsets ................................................................. 3 2.3 – Ouverture de la base de données.......................................................................................................... 3 2.4 - Affectation des tables aux recordsets................................................................................................... 3 2.5 - Navigation dans le jeu d'enregistrements .......................................................................................... 3 2.6 - Affichage des enregistrements ................................................................................................................ 3 2.7 - Ajouter un enregistrement à la fin du jeu........................................................................................... 3 2.8 - Modifier un jeu d'enregistrements ......................................................................................................... 3 2.9 - Annulation d'un ajout ou d'une modification ..................................................................................... 3 2.10 - Suppression d'un enregistrement........................................................................................................ 3 2.11 – Compter le nombre d'enregistrements dans un jeu d'enregistrements............................... 3 2.12 - Fermer les jeux d'enregistrements ..................................................................................................... 3 2.13 - Fermeture de la Base de données ....................................................................................................... 3 2.14 – Utilisation de requêtes ............................................................................................................................ 3

3. A.D.O (ACTIVE X DATA OBJECT)........................................................................................................................ 3 3.1 – Déclaration de la connexion .................................................................................................................... 3 3.2 – Déclaration des jeux d'enregistrements ou recordsets ................................................................. 3 3.3 – Définition du Provider ................................................................................................................................ 3 3.4 – Ouverture de la connexion ....................................................................................................................... 3 3.5 - Affectation des tables aux recordsets................................................................................................... 3 3.6 - Navigation dans le jeu d'enregistrements .......................................................................................... 3 3.7 - Affichage des enregistrements ................................................................................................................ 3 3.8 - Ajouter un enregistrement à la fin du jeu........................................................................................... 3 3.9 - Annulation d'un ajout.................................................................................................................................. 3 3.10 - Suppression d'un enregistrement........................................................................................................ 3 3.11 – Compter le nombre d'enregistrements dans un jeu d'enregistrements............................... 3 3.12 - Fermer les jeux d'enregistrements ..................................................................................................... 3 3.14 – Utilisation de requêtes ............................................................................................................................ 3

XI. DISTRIBUER UNE APPLICATION ........................................................................................................... 3 1. ATTENTION AUX IMAGES !............................................................................................................................................ 3 2. UTILISER L’INSTALLATEUR AUTOMATIQUE .................................................................................................................. 3


Mr Y. Safsouf 4/39

I. PRESENTATION DU LANGAGE VISUAL BASIC Visual Basic est un langage de conception orienté utilisateur. Il intègre le concept de la programmation événementielle, c’est à dire que les instructions sont déclenchées par des actions comme le clique sur un bouton de commande ou le déplacement d’un curseur dans une zone de texte. La plupart du temps, la programmation sous Visual Basic est scindée en deux étapes :

• La conception des interfaces graphiques, • L’écriture du code source.

Cependant, le développement de certains modules de programmation ne nécessite pas d’interface graphique.

1. Conception de l’interface graphique

Lorsque l’on conçoit une interface graphique, il est important de se mettre à la place de l’utilisateur. Pour cela, il faut être très rigoureux sur le choix des composants graphiques à utiliser et sur leurs comportements au sein de l’interface afin qu’elle soit la plus conviviale et la plus intuitive possible.

2. Ecriture du code source

Les instructions sont à inscrire dans les événements affectés aux objets graphiques composants l’interface. Exemple : on crée un bouton "quitter". On souhaite que lorsque l'on clique sur ce bouton la fenêtre se ferme. On inscrira donc les instructions correspondantes dans l’événement "click" du bouton "quitter".

II. Démarrage de Visual Basic Pour démarrer Visual Basic, cliquez sur le bouton Démarrer de la barre des taches. Dans le menu Démarrer, pointez sur Programmes. Dans la liste des Programmes, pointez sur Microsoft Visual Basic 6.0 (ou éventuellement Microsoft Visual Studio 6.0). L'écran des droits d'auteur de Visual Basic apparaît momentanément, puis la boîte de dialogue Nouveau projet s'ouvre.

La première fenêtre qui s'affiche lorsque vous lancez Visual Basic vous propose de choisir le type d'application que vous voulez créer. Sélectionnez la première icône marquée Exe.standard située dans l'onglet "Nouveau", puis cliquez sur le bouton "Ouvrir" pour afficher un nouveau projet. L'écran de création de Visual Basic apparaît.

• "Exe.standard" représente le modèle le plus courant pour réaliser la plupart des applications sous Visual basic


Mr Y. Safsouf 5/39

1. L'interface de travail de Visual Basic

Comme toutes les feuilles sous plate forme Windows l'interface de travail se présente avec une barre de titre, suivie d'une barre de menu et d'une barre d'outils. Diverses fenêtre s' ouvrent suivant la configuration souhaitée, à savoir les plus utilisées, la boîte à outils, la feuille de travail(Form1), la fenêtre de projet, la fenêtre de propriété.

L'environnement de développement intégré de Visual Basic peut être personnalisé, pour ce qui concerne sa présentation et son mode de fonctionnement.

2. Structure générale :

• Les objets manipulés sont appelés des contrôles (bouton de commande, boîte de dialogue, zône de texte, zône d'image, etc…).

• L'interface utilisateur créée est fenêtrée. Une fenêtre est appelée une feuille (Form). Une feuille est elle-même un contrôle.

• Chaque contrôle peut réagir à des événements qui lancent des suites d'instructions codées en BASIC.

• Des modules généraux de code BASIC peuvent porter sur tout le programme. Ces modules sont réutilisables.

3. Contrôles et propriétés

Un objet (contrôle) peut posséder un grand nombre de propriétés par exemple sur sa forme, sa couleur, sa position dans la feuille, sa visibilité, etc. La plus importante est la propriété Name qui donne un nom au contrôle. Ce nom permet de référencer le contrôle.


Mr Y. Safsouf 6/39

Syntaxiquement le nom d'un objet est séparé de la propriété par un point objet . propriété = valeur

Exemple 1 : form1.Caption = "Menu Principale " Exemple 2 : label1.Visible = True Exemple 3 : cmdQuitter.Enabled = False

4. Procédures événementielles

On en arrive à la deuxième grande possibilité supplémentaire des langages objet par rapport aux langages traditionnels. En PASCAL ou en C, par exemple, une application est constituée d’une procédure principale contenant la totalité du code (y compris par l’appel indirect à des sous-programmes). Les instructions qu’elle contient sont exécutées les unes après les autres, jusqu’à la fin. Le point fondamental est que dans un tel langage, l’ordre d’exécution des procédures et des sous-procédures est entièrement fixé d’avance par le programmeur lui-même, par le biais des instructions d’appel des sous-procédures. Par ailleurs, et ce n’est pas un hasard, ces procédures portent des noms arbitraires fixés par le programmeur, hormis le cas particulier de la procédure principale, qui se doit de porter un nom particulier, fixé par le langage (généralement, Main). Dans un langage objet, on peut, si on le désire, conserver intégralement ce mode de fonctionnement. Mais ce n’est plus le seul possible. En effet, dans un langage objet, il n’y a donc plus à proprement parler de procédure principale ; en tout cas, l’existence d’une procédure principale n’a rien d’obligatoire. Chaque procédure est liée à la survenue d’un événement sur un objet, et sera donc automatiquement exécutée lorsque cet événement se produit. Le nom de la procédure est alors, de manière obligatoire, le nom de la combinaison objet-événement qui la déclenche.

• On vient de parler des objets, et en particulier des contrôles. Répétons qu’un contrôle est un des éléments de l’interface graphique de Windows, éléments que VB met à la disposition du programmeur pour qu’il constitue ses propres applications. Ainsi, les contrôles les plus fréquents sont : la feuille, le bouton de commande, la liste, la case à cocher, le bouton radio, etc.

• Quant aux événements, ils peuvent être déclenchés par l’utilisateur, ou par déroulement du programme lui-même. Les événements déclenchés par l’utilisateur sont typiquement : la frappe au clavier, le clic, le double-clic, le cliquer-glisser. Les événements déclenchés par le code sont des instructions qui modifient, lors de leur exécution, une caractéristique de l’objet ; par exemple, le redimensionnement, le déplacement, etc.

Résumons-nous. Un petit dessin vaut parfois mieux qu’un grand discours :

Le lien entre l'objet, la survenue de l’événement et le déclenchement de la procédure est établi par le nom de la procédure lui-même. Ainsi, le nom d’une procédure événementielle répond à une syntaxe très précise :


Mr Y. Safsouf 7/39

5. Compilation et Interprétation

Lorsqu’on écrit une application Visual Basic (on ne traite ici que du cas standard, il en existe d’autres, mais qui sortent du sujet du cours), on crée donc un ensemble d’objets à partir des classes proposées, et on définit les procédures qui se rapportent à ces objets. Lorsqu’on sauvegarde cette application, Visual Basic va créer un certain nombre de fichiers. Pour l’essentiel : 1. un fichier dit Projet comportant l’extension *.vbp (les plus fûtés d’entre vous reconnaîtront là

l’acronyme de Visual Basic Project. Ils sont décidément très forts, chez Microsoft). Ce fichier rassemble les informations générales de votre application (en gros, la structure des différents objets Form, qui sont le squelette de toute application)

2. un fichier par objet Form créé, fichier portant l’extension *.frm. Ne soyez pas si impatients, vous saurez très bientôt ce qu’est un objet Form. Toujours est-il que si votre application comporte six Form, vous aurez en plus du fichier "projet", six fichiers "Form" à sauvegarder. Chacun de ces fichiers comporte les objets contenus par la "Form", ainsi que tout le code des procédures liées à ces objets.

3. éventuellement, d'autres fichiers correspondant à d'autres éléments de l'application, éléments dont nous parlerons plus tard (modules, modules de classe).

La destruction de l’un quelconque de ces fichiers vous portera naturellement un préjudice que l’on ne saurait sous-estimer. Conclusion, on crée un nouveau projet à chaque nouvelle application, et on ne déroge jamais à cette règle d’or. Il ne doit jamais y avoir deux projets ouverts en même temps dans la même fenêtre VB, sous peine de graves représailles de la part du logiciel. Voilà pourquoi, une fois l’application (le "projet") mis au point définitivement, VB vous propose de le compiler une bonne fois pour toutes, créant ainsi un unique fichier *.exe. Ce fichier contient cette fois à lui seul l’ensemble de votre projet, form, code, et tutti quanti. Et il peut naturellement être exécuté sans l’ouverture – donc la possession - préalable de Visual Basic (à un détail près, que nous réexaminerons plus loin dans ce cours). Un projet terminé est donc un projet compilé. Et qui, accessoirement, fonctionne sans erreurs.

6. Raccourcis de clavier :

Raccourci Fonction

F5 Exécution

Ctrl+Pause Bascule en mode arrêt, très utile en cas de verrou (boucle infinie sur une msgbox par ex.).

F7 Bascule vers le module de code d'une feuille. Shift+F7 Bascule du code vers l'objet. Shift+F2 en étant positionné sur un nom de procédure Affiche le code de la procédure appelée.

Ctrl+Shift+F2 Affiche la procédure précédemment consultée.

Ctrl+J Affiche à nouveau la liste automatique des méthodes et propriétés d'un objet. Se positionner dans la méthode ou la propriété à changer.

Ctrl+Shift+Initiale d'une propriété Accès immédiat dans la fenêtre des propriétés sur celle


Mr Y. Safsouf 8/39

commençant par l'initiale choisie.

III. Premiers Eléments du Code Visual Basic s’est voulu un langage simple. Vous pourrez juger par vous-mêmes de la réalité de cette prétention, mais il faut reconnaître que pour un certain nombre de choses élémentaires, les développeurs de Microsoft ont choisi de ne pas compliquer inutilement la vie du programmeur. Nous allons donc effectuer un premier, et très rapide, tour d’horizon, pour découvrir les syntaxes de base de ce langage.

1. Variables

Pour ce qui est des noms de variables, VB ne fait que dans le très classique. Voyez donc : • Les noms de variables n’ont pas de longueur maximale • Ils doivent commencer par un caractère • Ils ne doivent pas comporter d’espace • Ils ne sont pas sensibles à la casse (Toto et toto sont la même variable)

En ce qui concerne la déclaration de ces variables, celle-ci est optionnelle (en tout cas pour les variables locales, on reparlera dans un instant de cet aspect). Cela signifie que dans l’option par défaut, il n’est pas besoin de déclarer les variables pour s’en servir. Dans le cadre d’une grosse application, on devra activer l’option de déclaration des variables, ce qui permettra de gagner de l’espace mémoire (car les variables se déclarent par défaut avec le type le plus gourmand en mémoire, on y reviendra). Pour les types des variables, c'est tout pareil, rien que du très ordinaire et sans aucune surprise :

• Boolean : True – False • Byte : de 0 à 255 • Integer : de –32 768 à 32 767 • Long : de –2 à +2 milliards environ • Single : virgule flottante simple précision • Double : virgule flottante double précision • Currency : entier en virgule fixe • String : jusqu’à 65 000 caractères

Enfin, l'instruction d’affectation est le signe égal ( = ).

1.1 Déclaration, or not déclaration ?

On vient de voir que VB offrait la possibilité de déclarer ou non les variables (en tout cas, les variables locales). Mais, dans l’hypothèse de non déclaration systématique des variables, nous avions pudiquement glissé sur ce qui se passe lorsqu’une variable non déclarée est utilisée… En fait, cette variable est automatiquement créée dans un type spécial : le type Variant. Ce type possède comme particularité d’être "souple", à savoir de pouvoir s’ajuster à n’importe quel contenu (caractère, booléen, n’importe quel sous-type de numérique). Mais, évidemment, tout à un prix, et s’il est très pratique, le type variant n’en demeure pas moins extrêmement gourmand en mémoire vive occupée. Donc, si dans le cadre d’un petit exercice, on peut se permettre de ne pas déclarer ses variables, ce n’est pas le cas dans un projet, où l’accumulation des variables de type Variant peut conduire à de graves dysfonctionnements.

1.2 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.

Dim DateNaissance

Dim Message, Titre As String


Mr Y. Safsouf 9/39

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. 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.

1.3 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 il se rapportent :

• % : Integer • & : Long • ! : Single • # : Double • @ : Currency • $ : String 1.

1.4 Portée des variables

L’existence d’une variable peut se dérouler sur trois niveaux : Niveau Procédure : cela veut dire que la variable est locale. Dès que l’on quitte la procédure en question, la variable disparaît, et son contenu avec elle. Pour déclarer une variable au niveau procédure, on tape au sein de la procédure considérée :

Dim NomVariable as Type

Niveau Form : la variable est disponible pour toutes les procédures de la Form , mais pas pour les procédures se situant sur une autre Form. Pour déclarer une variable au niveau Form, on tape tout en haut de la Form, à l’extérieur des procédures :

Dim NomVariable as Type

Non, ce n’est pas une erreur, c’est bien la même chose que précédemment. Mais l’emplacement de l’instruction n’est pas le même, et c’est cela qui change tout. Niveau Projet : la variable est disponible, et sa valeur est conservée pour toutes les procédures de l’application, quel que soit leur emplacement. Pour déclarer une variable globale, il faut d’abord créer un module. Un module est un type de feuille destiné uniquement à recevoir du code, et qui n’a donc pas, contrairement aux Form, d’apparence graphique. C’est dans un module qu’on écrit la procédure principale, lorsqu’on en veut une, et qui de là pilote les différentes Form, elles mêmes donnant accès aux procédures liés aux objets qu’elles contiennent. Sur ce module, donc, on écrit :

Public NomVariable as Type

Naturellement, est-il besoin de le préciser, il ne faut pas raisonner en termes d’artillerie lourde, et déclarer toutes les variables au niveau projet, en se disant que comme ça, on est blindé : car ce blindage, par l’excès de place mémoire, ralentira votre application, au besoin considérablement. Il faut donc pour chaque variable se demander à quel niveau on en a besoin, et faire les déclarations en fonction.

1.5 Variables indicées (Les Tableaux)

On appelle aussi cela des tableaux ! Ce peut être des tableaux de nombres, de chaînes, de booléens, bref, de tout ce qu’on veut. Quant on crée un tableau, soit on sait d’avance combien d’éléments il va englober, soit on veut qu’il soit dynamique (mais cela se paye bien sûr par une perte de rapidité à l’exécution). Tout tableau doit obligatoirement être déclaré, quel que soit par ailleurs le réglage de l’option de déclaration des variables.

Dans l'exemple ci-après, les deux premières instructions sont équivalentes à la troisième :

Dim V1 As Integer V1 = 25

V1% = 25


Mr Y. Safsouf 10/39

Pour créer un tableau de 12 entiers, on écrira : Dim MonTableau(11) As Integer

Pour créer un tableau élastique (pour faire plus classe, ne dites pas « élastique », dites « dynamique »), on écrira :

Dim MonTableau() As Integer

Ensuite, dès qu’on veut en fixer la taille, on écrit dans le code : Redim MonTableau(11)

Si ce redimensionnement doit s’effectuer en conservant les valeurs précédemment entrées dans le tableau, on ajoutera le mot-clé Preserve :

Redim Preserve MonTableau(11)

En résumé, aucun problème spécifique ici que vous n’ayez déjà abordé sur un langage précédent (le C, par exemple, à tout hasard).

1.6 Les constantes

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))

2. Opérateurs

C'est d'une monotonie désespérante, mais là non plus, il n'y a aucune surprise en ce qui concerne les opérateurs, qui sont absolument standard. Je les rappelle rapidement :

• Opérateurs numériques : + - * /

• Opérateurs booléens : And Or Xor Not

• Opérateur caractères : & (concaténation)

3. Structure des tests :

3.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


Mr Y. Safsouf 11/39

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 qu’une ou deux instructions en fonction d'une condition. Par ailleurs, la valeur retournée par la condition est affectée à une variable.

3.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 , "Note"

End Select

If Semaine = 1 Then

Jour = "Lundi"

ElseIf Semaine = 2 Then

Jour = "Mardi"


Jour = "Mercredi"


Jour = "Jeudi"


Jour = "Vendredi"


Jour = "Samedi"



Mr Y. Safsouf 12/39

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é.

4. Structure des boucles :

4.1 La structure For..Next

La structure For...Next is 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 deux, 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.

4.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.

4.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


Mr Y. Safsouf 13/39

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.

IV. La Boite de Contrôles Les contrôles de Visual Basic aussi appelé OCX ou objets sont multipliables à l'infini grâce à la possibilité d'en créer directement avec Visual Basic. Tu te rendras aussi très vite compte que certains programmes rajoutent des OCX utilisables par VB lors de leur installation. Pour modifier la liste des OCX accessibles dans ton programme fais un clic droit sur la boîte à outils ( comme ci-contre à gauche) et sélectionnes "Composants". Les contrôles disponibles apparaissent sous l'onglet "Contrôles", il suffit alors de cocher les contrôles désirés pour pouvoir les utiliser dans ton projet. Les contrôles de bases presque toujours indispensables à tout projet sont les boutons, les zones de texte, les labels, la minuterie et l'image. Certains contrôles comme les lignes ou les formes ne réagissent à aucun évènement et ne servent qu'à rendre ton projet plus lisible. Tous les projets ( sauf exceptions ) sont composés d'au moins une feuille ou form dans laquelle se trouveront tes contrôles. En cliquant sur cette form tu verras ses propriétés s'afficher sur la droite de l'écran (ci-contre à droite). Grâce à cette fenêtre tu pourras modifier certains aspects de la form comme ses couleurs, son image de fond, son nom, sa taille... Cette fenêtre correspond toujours à l'objet sélectionné et se met à jour automatiquement dès qu'on clique sur un autre objet. Etudions les différents contrôles de la boîte à outils.

Nom du contrôle Description

PictureBox C'est un conteneur d' autres objets. Vous pouvez insérer une image ou par exemple un groupe d' objets en une seule opération

Label On utilise ce contrôle pour placer du texte comme affichage simple ou comme étiquette.(L' utilisateur ne peut pas modifier le texte saisi dans ce contrôle)

TextBox C' est le seul objet qui vous permet de saisir du texte, des nombres ou des dates.

Frame

Ce contrôle sert à enjoliver votre présentation. Un autre contrôle remplit le même rôle mais n' est pas livré en standard, c 'est le contrôle Sheridan 3D Controls qui est généré par le fichier Threed32.ocx.(A posséder impérativement)

CommandButton C'est un bouton poussoir qui enclenchera une action par l' intermédiaire d' une procédure événementielle.

CheckBox C'est une case à cocher

OptionButton C'est un bouton radio(Option)

ComboBox Il s' agit d' une liste modifiable qui permet de choisir un seul élément dans une liste mais aussi de taper une valeur qui n' est pas affichée

ListBox C'est une liste dans laquelle vous pouvez choisir un ou plusieurs éléments, sans pouvoir saisir de nouvelle valeur.

HScrollBar C'est un ascenseur horizontal

VScrollBar C'est un ascenseur vertical

Timer C'est une minuterie, genre chronomètre qui vous permet d' enclencher une action toutes les n milli-secondes

DriveListBox Ce contrôle permet d' afficher la liste de tous les lecteurs disponibles sur l' ordinateur

DirListBox Ce contrôle permet d' afficher la liste de tous les répertoires d' un


Mr Y. Safsouf 14/39

lecteur sélectionné

FileListBox Ce contrôle permet d' afficher la liste de tous les fichiers d' un répertoire sélectionné

Shape Permet de dessiner des formes, rectangles, cercles

Line Permet de dessiner des lignes

Image Sert à insérer des images, nous le préférerons à l' objet PictureBox

Data Ce contrôle permet de programmer l' accès aux bases de données

OLE Il permet de placer des applications OLE(Object Link and Embedding)

Avant de programmer avec Visual Basic, vous devez vous familiariser avec son environnement graphique, ses menus, ses barres d'outils ainsi que les fenêtres qui permettent de programmer et de paramétrer les différents objets. Voici un tableau des propriétés les plus fréquentes et les plus simples :

1. Le CommandButton (Bouton de Commande) – (voir TP 1.1, TP 1.2, TP 1.3)

Il s’agit du bouton type OK, Annuler, mais dont le texte apparent (en Anglais, Caption) et le rôle dans une application peuvent varier à l’infini. Je ne vous étonnerai pas en vous disant que l’action que VB considère comme étant la plus commune pour les boutons de commande est Click (en Français, clic, note du traducteur, 20/20 au TOEIC). Quelques propriétés intéressantes de la classe CommandButton :

• Name : bien sûr ! • Caption : évidemment… • Visible : ce qui ne surprend pas.

Nom: Utilité:

Align ou Alignement Définit l'alignement du texte contenu dans le contrôle.

Appearence Définit si l'objet doit paraître en 3D ou en 2D.

Backcolor Choix de la couleur d'arrière plan du contrôle.

Borderstyle Définit le type de bordures qui entourent le contrôle.

Caption Titre du contrôle

Enabled Rend le contrôle accessible à l'utilisateur ou non

Font Choix du style d'écriture dans le contrôle

Forecolor Couleur du texte contenu dans le contrôle

Heigth Hauteur du contrôle en Twip ( correspond à un point sur l'écran )

Left Position horizontale du contrôle par rapport à l'objet contenant le contrôle ( cf. frame et PictureBox)

Mouseicon Icône qu'adoptera le pointeur de la souris au-dessus de ce contrôle. (nécessite que la propriété Mousepointer prenne la valeur 99)

Mousepointer Type de pointeur par défaut de la souris

Rigthtoleft Sens d'écriture dans le contrôle

Top Position verticale du contrôle par rapport à l'objet contenant le contrôle ( cf. frame et PictureBox)

Text Texte que contient le contrôle (propriété modifiable par l'utilisateur)

Visible Définit si le contrôle est visible ou invisible

Width Largeur du contrôle en Twip


Mr Y. Safsouf 15/39

• Enabled : cette propriété, booléenne, est comme on le verra très loin d’être l’apanage des seuls boutons de commande. Elle permet (valeur True) à un contrôle d’être actif, c’est-à-dire de pouvoir recevoir des événements, et donc de déclencher des procédures. Inversement, elle interdit (valeur False) à un contrôle de recevoir quelque événement que ce soit de la part de l’utilisateur. Dans ce cas, le contrôle apparaît grisé à l’écran. Ca vous rappelle des choses déjà vécues sous Windows ? Normal, c’est absolument fait exprès.

• Style : si cette propriété possède comme valeur Graphical, il devient alors possible d’ajouter une image sur le bouton, ou d'en modifier la couleur. Dans le cas contraire (valeur Standard, par défaut), le bouton conserve l’aspect par défaut des boutons de Windows, à savoir un gris souris du meilleur goût.

2. Le Label (Etiquette)

Un Label est un contrôle "inerte", qui sert à afficher un texte sur une Form. Son aspect peut varier quelque peu selon les styles adoptés : Ce qu’il faut comprendre avec les Labels, c’est qu’ils ne peuvent jamais servir à effectuer une saisie par l’utilisateur. Pour le reste, les propriétés notables d’un contrôle Label sont :

• Name : bien sûr • Caption : évidemment • Alignment : qui règle l’alignement du texte (gauche, centré, droite) • BorderStyle : qui désigne le type de bordure

Quant aux événements possibles sur un contrôle Label, disons en première approche qu’ils incluent le Click déjà vu, plus d’autres événements dont nous ne parlerons que plus loin.

3. La Zone de Texte (TextBox)

Ces zones (de la classe "TextBox" pour VB) peuvent servir à saisir une information. Il s’agit du seul contrôle permettant une saisie au clavier par l’utilisateur. En Visual Basic, il n’y a donc plus à proprement parler d’instruction Lire. A la place de cette instruction, on est contraint de passer par de telles zones. La seule chose vraiment importante à savoir est que toute information contenue dans une zone de texte est obligatoirement de type… texte ! (autrement dit, cela inclut le cas où il s’agit d’un nombre). Conclusion, l’emploi de fonctions de conversion s’avèrera fréquemment indispensable La propriété essentielle d'une Zone de Texte est… Text. C’est la propriété qui désigne son contenu. Comme toute propriété, elle va pouvoir être utilisée tant en lecture qu’en écriture. Supposons ainsi que nous avons défini une zone de classe TextBox, que nous avons appelée "NomDeFamille". Pour mettre cette zone à blanc à l’affichage de la feuille de dialogue, on écrira tout simplement :

Nomdefamille.Text = ""

Une fois que l’utilisateur aura entré quelque chose dans cette zone, si l’on veut récupérer ce quelque chose dans la variable Toto, on passera l’instruction suivante :

Toto = Nomdefamille.Text

Autres propriétés intéressantes des zones de texte : • Multiline : autorise ou non l’écriture sur plusieurs lignes • Scrollbars : fait figurer dans la TextBox une barre de défilement horizontale ou verticale

(ou les deux) • PasswordChar : crypte le texte entré par le caractère stipulé (généralement, on choisit

le caractère *) • MaxLength : limite le nombre de caractères qu’il est possible de saisir dans la zone de

texte.


Mr Y. Safsouf 16/39

On retrouve bien entendu à propos des zones de texte les événements déjà aperçus à propos des contrôles précédents, comme le Click. Toutefois, un nouvel événement fait son apparition : il s'agit de Change, qui survient chaque fois que le contenu de la zone de texte est modifié. Cet événement peut donc survenir :

• soit parce que l'utilisateur a frappé un texte dans la zone - et dans ce cas, il provoque un événement Change à chaque nouveau caractère frappé

• soit parce qu'une ligne de code provoque une modification de la propriété Text de cette zone.

Il faut donc bien réfléchir avant d'écrire une procédure liée à une zone de texte : quand veut-on qu'elle se déclenche ? Et même, souhaite-t-on réellement déclencher une procédure à chaque fois que quelque chose est modifié dans cette zone ?

4. Les Cases – (voir TP 2.1, TP 2.2, TP 2.3, TP 2.4)

Il existe sous Windows deux sortes de cases : • les cases dites "cases à cocher" (Checkbox): Elles sont carrées, et indépendantes les

unes des autres, même si elles sont regroupées dans un cadre pour faire plus joli.

• les cases dites "cases d’option", voire "boutons radio" (OptionButton). Elles sont rondes

et font toujours partie d’un ensemble (dessiné par l’objet Frame). Au sein d’un ensemble de cases d’option, jamais plus d’une seule case ne peut être cochée à la fois.

Moralité, avant de mettre des cases et d’écrire le code qui s’y rapporte, il faut bien se demander de quel type de cases on a besoin. Une fois ce préambule posé, il n’y a pas de problèmes particuliers, hormis que pour des cases d'option, il faut toujours créer le Frame avant de poser des cases à l’intérieur de ce


Mr Y. Safsouf 17/39

Frame. Dans le cas contraire, le langage ne reconnaîtra pas les cases comme faisant partie du même ensemble, et elles auront un comportement erratique. Sinon, la propriété la plus intéressante d’une case est de loin celle qui nous permet de savoir si elle est cochée ou non. Cette propriété s’appelle Value.

• Value prend la valeur True ou False lorsqu’elle concerne les cases d’option. • Value prend la valeur 1 ou 0 lorsqu’elle s’applique aux cases à cocher. Cette différence de

traitement peut paraître aberrante, mais il faut se rappeler que les cases à cocher peuvent aussi posséder un état intermédiaire grisé. Auquel cas leur propriété Value prend la valeur 2.

Comme toute propriété, Value peut être utilisée en écriture (pour initialiser telle ou telle case au moment où elle arrive à l’écran) ou en lecture (pour tester quelle case a coché l’utilisateur, et accomplir du coup un traitement ou un autre).

5. Les Listes – (voir TP 3.1, TP 3.2)

Les listes classiques dans Windows peuvent posséder ou non deux caractéristiques. • Elles peuvent être modifiables : c’est-à-dire que l’utilisateur a la possibilité d’entrer un

élément qui ne figure pas au départ dans la liste. Cette caractéristique concerne donc les données de la liste proprement dites.

• Elles peuvent être déroulantes : c’est-à-dire qu’on ne voit qu’un seul élément de la liste à la fois, et qu’il faut cliquer sur la flèche du côté pour "déplier" la liste. Cette caractéristique joue donc uniquement sur l’aspect de la liste, et aucunement sur la manière dont les données sont gérées.

Une liste peut donc prendre quatre têtes, selon qu’elle est modifiable ou non, déroulante ou non ("chez les papous, y a les papous à poux et les papous pas à poux, etc.") VB fournit deux contrôles de liste :

• une liste dite simple : contrôle ListBox • une liste dite modifiable : contrôle ComboBox

Le gag (ce Bill Gates, quand même, quel rigolo), c’est qu’en réalité, la liste dite modifiable est aussi une liste déroulante… Alors, pour résumer la situation, voici un petit récapitulatif de ce qu’il faut utiliser :

LISTE Non déroulante Déroulante

Non modifiable ListBox ComboBox

Style = 2

Modifiable ComboBox

Style = 1

ComboBox

Style = 0 (défaut)

Propriétés indispensables :

• ListIndex : renvoie ou définit l’indice de l’élément actuellement sélectionné. En fait, en interne, VB gère les listes un peu à la manière des tableaux. Il attribue donc à chaque élément d’une liste un indice, cet indice commençant toujours à zéro. A noter que si aucun élément n'est sélectionné dans la liste, la propriété Listindex vaut -1.

• List : Savoir quel est l’indice de l’élément sélectionné dans une liste, c’est bien. Mais savoir à quel texte correspond cet indice, c’est mieux ! Cette propriété renvoie en clair (sous forme de texte) un élément d’une liste en fonction de son indice. Il s’agit donc, chose assez rare, d’une propriété qui nécessite un argument (le numéro d’indice).

Pour récupérer sous forme de texte l’élément actuellement sélectionné dans la liste appelée Produits, on écrira donc le code suivant :

NuméroProduit = Produits.ListIndex

NomProduit = Produits.List(NuméroProduit)

MsgBox "Vous avez choisi le produit : " & NomProduit


Mr Y. Safsouf 18/39

Ou plus directement : NomProduit = Produits.List(Produits.ListIndex)


Toutefois, il faut noter que les contrôles ComboBox nous simplifient grandement la vie, puisqu'à la différence des ListBox, ils nous proposent directement une propriété Text. Ainsi, si Produits est un contrôle ComboBox, et uniquement dans ce cas, on pourra écrire :

NomProduit = Produits.Text


• ListCount, qui renvoie le nombre d’éléments d’une liste (propriété numérique) • Multiselect, qui permet la sélection multiple (propriété booléenne) • Sorted, qui trie automatiquement les éléments d’une liste (propriété booléenne)

Nous découvrons avec les contrôles ListBox et ComboBox des méthodes qu'il est indispensable de connaître afin de gérer des objets de type liste :

• AddItem Chaîne : ajoute l'élément Chaîne à une liste (un argument supplémentaire, facultatif, permet éventuellement de spécifier à quel indice l'élément doit être inséré).

• RemoveItem (indice) : supprime de la liste l'élément possédant l'indice spécifié. • Clear : efface tous les éléments d’une liste

Comme à l'accoutumée, voilà deux petits exercices pour se mettre tout cela en tête. List1.clear

List1.AddItem ("Pomme")

List1.AddItem ("Poire")

List1.AddItem ("Pêche")

6. Trois autres contrôles (DriveListBox, DirListBox, FileListBox) – (voir TP 4.1)

Il n'est pas rare que dans une application, on doive permettre à l'utilisateur de naviguer dans le disque dur, les répertoires, les fichiers, etc. (comme dans la commande Fichier – Ouvrir de tout logiciel). Pour réaliser cela, on va avoir recours à trois contrôles supplémentaires, spécialisés, dont le rôle est de reproduire des outils familiers sous Windows :

• DriveListBox : qui fournit automatiquement la liste des lecteurs logiques disponibles sur la machine où tourne l'application.

• DirListBox qui fournit automatiquement la liste des répertoires contenus dans une unité donnée

• FileListBox qui fournit automatiquement la liste des fichiers contenus dans un répertoire donné.


Mr Y. Safsouf 19/39

La présence de ces contrôles soulage votre tâche, mais ne vous épargne toutefois pas totalement d’écrire un chouïa de code, afin de les faire fonctionner ensemble. Ces trois objets étant des cas particuliers de contrôle liste, s’y appliquent éventuellement List, Listcount et Listindex. Mais pour gérer la mise à jour de ces contrôles les uns en fonction des autres, les propriétés suivantes sont indispensables (et suffisantes) :

• Drive : qui renvoie ou définit l'unité logique actuellement en vigueur dans un contrôle DriveListBox

• Path : qui renvoie ou définit le chemin actuellement en vigueur dans un contrôle DirListBox ou dans un contrôle FileListBox

• Filename : qui renvoie ou définit le fichier actuellement sélectionné dans un contrôle FileListBox.

Allez, un peu de pratique n'a jamais fait de mal à personne : Private Sub Drive1_Change()

Dir1.Path = Drive1.Drive

End Sub

Private Sub Dir1_Change()

File1.Path = Dir1.Path

End Sub

Private Sub Command2_Click()

MsgBox "Vous avez choisi : " & Dir1.Path & File1.FileName, vbInformation

End Sub

7. Un contrôle particulier : le Timer – (voir TP 4.2)

Il s’agit du petit chronomètre situé dans la barre de contrôles. Ce contrôle joue un rôle fondamental et indispensable : c’est lui qui va permettre d’effectuer des traitements, à intervalles fixés d'avance, indépendamment des actions effectuées par l’utilisateur. Jusqu’à présent, en effet, le code ne s’exécutait (si l’on met de côté le Form_Load et une éventuelle procédure principale située dans un module) qu’au cas où l’utilisateur faisait quelque chose : saisie au clavier, mouvement ou clic de souris, etc. Or, on peut tout à fait avoir besoin, dans certaines applications, que le code se mette en route, même si l’utilisateur ne fait rien du tout. Le contrôle Timer, graphiquement toujours invisible, va générer des événements, des "tops", à une cadence choisie par le programmeur, qui déclencheront la procédure NomDuTimer_Timer(). Le programmeur pourra donc mettre dans cette procédure tout ce qui doit se passer indépendamment de ce que fera – ou ne fera pas - l’utilisateur. Un Timer est très utile dans certains jeux, soit qu’on ait besoin de chronométrer quelque chose, soit qu’on ait besoin de provoquer certains événements à intervalles réguliers (un déplacement d’un bidule, la survenue d’un événement du jeu tiré au hasard, etc.) La propriété essentielle d'un Timer est Interval. C'est elle qui fixe l'intervalle entre chaque top, exprimé en millisecondes).

Dim temps As Integer

Private Sub Form_Load()

temps = 10

End Sub

Private Sub Timer1_Timer()

temps = temps - 1

If temps > 0 Then

Label1.Caption = temps


Mr Y. Safsouf 20/39

Else

Form1.Hide

MsgBox "Boum ! Ha ! Ha ! Ha !", vbExclamation

End

End If

End Sub

8. Les tableurs – (voir TP 5.1)

Le contrôle MSFlexGrid affiche et manipule des données sous forme de tableaux. Il offre un grand éventail de possibilités pour le tri, la fusion et la mise en forme de tableaux contenant des chaînes de caractères et des images. Lorsqu'il est dépendant d'un contrôle Data, le contrôle MsFlexGrid affiche des données en lecture seule. Les propriétés Row et Col d'un contrôle MSFlexBGrid permettent de spécifier la cellule active. Celle-ci peut également être définie dans le code ou modifiée par l'utilisateur au moment de l'exécution à l'aide de la souris ou des flèches directionnelles. La propriété Text renvoie au contenu de la cellule courante. Le nombre des colonnes et des lignes d'un contrôle MSFlexGrid est défini à l'aide des propriétés Cols et Rows. Note de distribution : Vous devez ajouter le fichier MSFlxGrd.ocx à votre projet avant de pouvoir utiliser un contrôle MSFlexGrid dans votre application. Lorsque vous distribuez votre application, installez le fichier MSFlxGrd.ocx dans le dossier System de Windows " System32 ".

Rows Elle permet de définir ou de connaître le nombre de lignes du contrôle.

Cols Elle permet de définir ou de connaître le nombre de colonnes du contrôle.

FixedRows Elle permet de définir ou de connaître le nombre de lignes fixes du contrôle.

FixedCols Elle permet de définir ou de connaître le nombre de colonnes fixes du contrôle.

Row Elle permet de définir ou de connaître les coordonnées de la cellule courante.

Col Elle permet de définir ou de connaître les coordonnées de la cellule courante.

Text Elle permet de définir ou de connaître le contenu de la cellule courante.

ColWidth Elle permet de définir ou de connaître la largeur d'une colonne.

RowHeight Elle permet de définir ou de connaître la hauteur d'une ligne.

ColAlignment Elle permet de définir ou de connaître l'alignement des données d'une colonne.

RowSel Elle permet de sélectionner ou de connaître les coordonnées d'une plage de cellules.

ColSel Elle permet de sélectionner ou de connaître les coordonnées d'une plage de cellules.


Mr Y. Safsouf 21/39

V. Autres Propriétés des contrôles On n’examinera ici que certaines des propriétés les plus courantes, celles que l’on retrouve pour la majorité, sinon la totalité, des contrôles. Bien entendu, vous avez déjà expérimenté un certain nombre de ces choses, et il ne s'agit là que d'un petit complément..

1. Localisation des contrôles – (voir TP 6.1)

Tout contrôle placé sur une Form possède deux propriétés qui régissent son emplacement : • Top : distance séparant le bord supérieur du contrôle du haut de la Form • Left : distance séparant le bord gauche du contrôle de la gauche de la Form

Comme vous le savez aussi, il y a également deux propriétés qui règlent la taille du contrôle. Ce sont :

• Width qui spécifie sa largeur • Height qui stipule sa hauteur

Avec ces quatre propriétés, on règle donc et la taille et l’emplacement de tout contrôle, et on peut faire des choses graphiquement très joulies. CQFD.

2. Activation des contrôles – (voir TP 6.2)

La plupart des contrôles possèdent les propriétés suivantes : • Enabled : permet / interdit l’action de l’utilisateur sur le contrôle considéré. Bon nombre

de contrôles (mais pas tous) deviennent grisés lorsque cette propriété est False. Vous l'aurez deviné, il s'agit d'une propriété booléenne.

• Visible : affiche / cache le contrôle considéré (et du même coup, permet / interdit) au contrôle de recevoir des événements clavier ou souris. C’est fou ce qu’on peut faire avec ce petit machin là. Comme la précédente, cette propriété est booléenne.

• Tabindex : règle l’ordre de tabulation des contrôles dans la Form (propriété de type Integer).

VI. Les Evénements On va dans cette partie aborder des événements jusque là injustement dédaignés. Je passe rapidement sur le Click et le DblClick, qui n’ont plus de secrets pour vous. Toutefois, c'est le moment de préciser un détail important : un contrôle ne peut pas à la fois posséder une procédure liée au click (simple) et au double click, car un des deux événements intercepte toujours l'autre. clic ou double clic, le concepteur d'interface doit donc choisir entre les deux ! Plus intéressants, car moins connus, en voici quelques autres :

1. Evénements Focus

Le focus est le fait, pour un contrôle, d’être celui qui est actuellement désigné par la tabulation (un petit liseré en pointillé apparaît autour d’un objet lorsqu’il a le focus, ou dans le cas des zones de texte, le curseur clignote à l'intérieur). Deux événements sont liés à la réception ou à la perte du focus :

• Gotfocus : quand l’objet reçoit le focus • Lostfocus : quand l’objet perd le focus

J’en profite négligemment au passage pour signaler qu’une instruction permet de forcer le passage du focus à tel ou tel contrôle. Il s’agit de la méthode Setfocus. Ainsi, la ligne de code :

TrucMuche.Setfocus

envoie de gré ou de force le focus sur le contrôle TrucMuche.

2. Evénements clavier – (voir TP 7.1)

On peut être amené, dans une application, à vouloir "guetter" la frappe de touches du clavier par l’utilisateur. Ceci recouvre grosse moto deux cas :

• On veut gérer la saisie caractère par caractère dans un contrôle Textbox ou ComboBox. Ceci pour contrôler au fur et à mesure la validité des caractères frappés (éliminer les


Mr Y. Safsouf 22/39

chiffres, par exemple…) ou convertir les caractères au fur et à mesure les caractères frappés (les convertir automatiquement en minuscules ou en majuscules, par exemple…). Dans ce cas, on pourra gérer les événements KeyPress KeyUp ou Keydown (voir plus loin pour le choix) au contrôle concerné.

• On souhaite affecter, indépendamment de tout problème de saisie dans un contrôle, certaines actions à certaines touches du clavier. Typiquement, affecter les touches de fonctions : F1 pour ouvrir l'aide, etc. Ici, c’est à la Form que l’événement clavier devra être associé. Mais cela ne fonctionnera que si la propriété KeyPreview de la Form possède la valeur True. Dans ce cas, la Form reçoit ces événements avant les contrôles qu'elle contient.

La différence fondamentale entre KeyPress d’une part, et Keydown et Keyup d’autre part, c’est que KeyPress considère quel caractère a été frappé (le résultat logiciel de la frappe), alors que Keydown et Keyup considèrent l’état physique du clavier. Par conséquent : KeyPress ne reconnaît pas les frappes ne produisant pas directement un caractère, comme les touches de fonction, les touches de modification, les touches de navigation et toutes les combinaisons de ces touches avec les modificateurs du clavier. En revanche, Keydown et Keyup gèrent parfaitement tout cela. Autre différence, KeyPress interprète la majuscule et la minuscule de chaque caractère comme des codes de touche distincts et, par conséquent, comme deux caractères différents. KeyDown et KeyUp, quant à eux, interprètent la majuscule et la minuscule de chaque caractère au moyen de deux arguments : keycode, qui indique la touche physique (A et a étant alors équivalents) et shift, qui indique l'état de shift + key et qui renvoie en conséquence soit A, soit a. Dernière chose sur ce chapitre, Keydown détecte le moment où une touche est enfoncée, KeyUp celui où elle est relâchée. La gestion fine des événements clavier restant une chose relativement pénible en Visual Basic, nous passons rapidement à quelque chose de beaucoup plus répandu…

3. Evénements souris – (voir TP 7.2, TP 7.3)

MouseDown et MouseUp sont deux événements détectant respectivement le fait qu’un bouton de la souris a été enfoncé ou relâché au dessus d’un objet. Un aspect fondamental de ces événements, c'est que la procédure qui leur est associée possède un certain nombre de paramètres. C'était déjà le cas avec les événements claviers ci-dessus, mais j'avais alors jeté un voile pudique sur cet aspect. En tout cas, là, avec la souris, on n'y coupera pas. Les paramètres en entrée de toute procédure liée à un événement souris sont là pour vous permettre notamment de récupérer dans cette procédure :

• quel bouton de la souris a provoqué l’événement (bouton de gauche, bouton de droite, etc.)

• l’état des touches Maj, Ctrl et Alt du clavier. Ceci permet de gérer des combinaisons alambiquées clavier + souris. A réserver uniquement aux émules des interfaces Adobe.

• les coordonnées x et y désignant l’endroit où l’événement s’est produit. Et là, gaffe de chez gaffe ! Ces coordonnées sont toujours relatives à l’objet ayant reçu l'événement. Donc ce ne sont les coordonnées par rapport à la Form que si l’objet recevant l’action est bien la Form. Réciproquement, si on gère un MouseDown sur une image, le X et le Y désigneront la position de la souris par rapport à cette image au moment du MouseDown. Si l'on veut en déduire les coordonnées de la souris par rapport à la Form, il faudra ajouter les coordonnées de l'image dans le Form. Tout le monde suit ?

Quant à l'événement MouseMove, il détecte le déplacement de la souris au-dessus d’un xontrôle. Cet événement possède les mêmes paramètres que les deux événements précédents. Par ailleurs, il faut signaler en passant qu’en VB, les possibilités de personnaliser l’apparence de la souris sont nombreuses et simples d’utilisation. Chaque contrôle possède ainsi deux propriétés chargées uniquement de gérer cet aspect des choses :

• MousePointer: indique quelle tête la souris doit prendre lorsqu’elle survole l’objet, tête, choisie parmi la liste des possibilité standard de Windows.


Mr Y. Safsouf 23/39

• MouseIcon désigne un fichier image (type *.ico ou *.cur) définissant un pointeur de souris personnalisé.

On peut donc très facilement, en affectant l'une ou l'autre de ces propriétés (pas les deux en même temps, ça n'aurait aucun sens), faire en sorte que le pointeur de la souris change de tête au survol de tel ou tel contrôle. C'est un des petits détails qui donnent à une interface un look professionnel et "fini", et celui-là, comme on le voit, ne coûte vraiment pas cher.

VII. Quelques Fonctions On va bien entendu retrouver dans VB les fonctions standard présentes dans quasiment tous les langages. Je passe sur les fonctions mathématiques (trigonométriques ou autres…) pour inventorier rapidement les fonctions plus "algorithmiques":

1. Traitement des chaînes :

• Mid (Nomdechaîne, nombre1, nombre2) : renvoie une chaîne, extraite de Nomdechaîne, commençant au caractère numéro nombre1 et faisant nombre2 caractères de long

• Len (Nomdechaîne) : renvoie le nombre de caractères de Nomdechaîne. • Et bien d'autres ! Quelques nouveautés à ce propos : • LTrim (Nomdechaîne) : renvoie la chaîne Nomdechaine, débarrassée de tous les

espaces se trouvant à gauche. • Rtrim (Nomdechaîne) : renvoie la chaîne Nomdechaîne, débarrassée de tous les

espaces se trouvant à droite. • AllTrim (Nomdechaîne) : renvoie la chaîne Nomdechaîne, débarrassée de tous les

espaces se trouvant à droite et à gauche.

2. Fonctions numériques :

• Int (nombre) : renvoie la partie entière de ce nombre • Rnd () : renvoie un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu). NB :

pour que Rnd () ne renvoie pas le même nombre, ou la même série de nombres, à chaque exécution, il faut systématiquement le faire précéder de l’instruction Randomize (toute seule, sur une ligne)

• Val (Chaîne) : renvoie un nombre si Chaîne est composée de chiffres • Str (Nombre) : renvoie Nombre sous forme de chiffres (c'est-à-dire de caractères)

3. La fonction MsgBox – (voir TP 8.1, TP 8.2)

Comment envoyer facilement des informations à l’utilisateur ? La réponse à cette question qui vous taraude se trouve dans les lignes qui suivent. Bien sûr, si vous souhaitez envoyer des messages riches, compliqués et/ou présentés d’une manière originale, la seule solution reste de programmer des Form correspondant à vos souhaits et de passer les instructions VB nécessaires pour qu’elles contiennent les informations voulues. Mais si votre seule ambition, à un moment donné d’une application, est d’envoyer un message à l’utilisateur qui se limite à un texte, ou à un chiffre, ou même à une combinaison des deux, avec comme seuls boutons possibles un bouton OK, Annuler, etc., alors VB met à votre disposition la fonction MsgBox. Vous pourrez ainsi à moindre frais envoyer à l’écran des mini-boîtes de dialogue d’un type bien connu par tous les utilisateurs de Windows, du style : L’originalité de la chose, qui peut quelque peu dérouter au début, est donc que l’on passe par une fonction pour exécuter quelque chose qui ressemble à une instruction Ecrire en algorithmique. Mais, en réalité, le paradoxe n’en est pas un. Car une petite boîte de dialogue comme celle présentée ci-dessus, si elle envoie bel et bien un message à l’utilisateur, récupère également une réponse de cet utilisateur (sur quel bouton a-t-il appuyé). Dès lors, on se dit que quelque


Mr Y. Safsouf 24/39

chose qui comporte plusieurs paramètres en entrée et une valeur en sortie, a toutes les chances d’être considéré comme une fonction par un langage… CQFD !

La syntaxe de la fonction MsgBox est : Variable = MsgBox (texte1, integer, texte2, ... )

La fonction MsgBox comporte donc trois arguments essentiels, qui sont respectivement : • le texte du message à envoyer • le style des boutons et de l’icône éventuelle à faire figurer sur le message • le texte de la barre de titre

En ce qui concerne les deux arguments de type texte, aucun problème. En revanche, le deuxième argument, de type Integer, mérite qu’on s’y arrête. Cet Entier (Integer) va donc avoir pour rôle de spécifier tout à la fois le type d’icône employée dans la boîte de message, et l’échantillon des boutons proposés à l’utilisateur. Toutefois, cet argument peut être spécifié de deux manières différentes qu’il convient de connaître :

• Chaque possibilité d’icône ou de boutons est associée à un nombre entier (voir l’Aide du logiciel). Pour obtenir la combinaison voulue, il suffit d’additionner les nombres correspondants, et c’est cette somme qui sera le deuxième argument.

• l'autre façon de spécifier cet argument consiste à employer des Constantes VB. Ces Constantes VB sont des mots réservés du langage, qui sont traduits par le compilateur en nombre entiers. Du point de vue du résultat, cette solution est donc strictement équivalente à la précédente, où on entrait directement des nombres. En revanche, certains programmeurs la préféreront en raison de la plus grande lisibilité qu’elle introduit dans le code. A noter que Ces Constantes VB ne s’inventent pas ! Elles figurent dans l’Aide du logiciel, et c’est là qu’il faut les chercher (elles apparaissent toutefois sous forme de liste déroulante lorsqu'on entre le code dans l'éditeur. Avec un tout petit peu d'habitude, le choix en est grandement facilité…

A titre d’illustration, la boîte de dialogue située au-dessus pourrait être indifféremment programmée par :

Texte = "Enregistrer les modifications (...) ?"

Titre = "Microsoft FrontPage"

Toto = MsgBox ( Texte, 51, Titre )

Ou par : Texte = "Enregistrer les modifications (...) ?"

Titre = "Microsoft FrontPage"

Toto = MsgBox (Texte, vbExclamation + vbYesNoCancel, Titre)

Les constantes pour les boutons Constante Chiffre Description vbOKOnly 0 Affiche le bouton OK uniquement vbOKCancel 1 Affiche les boutons Ok et Annuler vbCancelRetryIgnore 2 Affiche les boutons Abandonner, Répéter et Ignorer vbYesNoCancel 3 Affiche les boutons Oui, Non et Annuler vbYesNo 4 Affiche les boutons Oui et Non vbRetryCancel 5 Affiche les boutons Répéter et Annuler Les constantes pour les icônes Constante Chiffre Description vbCritical 16 Affiche l'icône message critique vbQuestion 32 Affiche l' icône requête d' avertissement vbExclamation 48 Affiche l'icône message d' avertissement vbInformation 64 Affiche l'icône message d' information Les constantes pour le bouton par défaut


Mr Y. Safsouf 25/39

Constante Chiffre Description vbDefaultButton 10 Le premier bouton est le bouton par défaut vbDefaultButton 256 Le deuxième bouton est le bouton par défaut vbDefaultButton 512 Le troisième bouton est le bouton par défaut

Chaque bouton lorsqu'il est activé, renvoie une valeur que l’on pourra interpréter au travers de la variable. Si vous ne mettez pas le paramètre "Type" l’instruction MsgBox n’affichera que le bouton "OK"

Les constantes renvoyées par MsgBox Constante Chiffre Description vbOk 1 OK vbCancel 2 Annuler vbAbort 3 Abandonner vbRetry 4 Réessayer vbIgnore 5 Ignorer vbYes 6 Oui vbNo 7 Non

Le code suivant montre un exemple de paramétrage de boîte de dialogue MsgBox avec retour de valeur d'une variable

Private Sub Button_Supprime_Click ( )

Dim Sup

Sup = MsgBox("Veuillez confirmer la suppression du fichier", vbCritical +

vbYesNo + 256, "Attention")

If Sup = vbYes Then

MsgBox "Suppression confirmée"

End If

End Sub

En résumé, MsgBox est une fonction qui vous donne accès à un type de Form préprogrammé, aux fonctionnalités limitées, mais à la programmation très rapide.

4. La boîte de dialogue "InputBox"

Comme pour les messages, Visual Basic propose une fonction simple permettant de créer une boîte de dialogue InputBox. Elle est activée par l' appel suivant:

Variable$ = InputBox$(Prompt$, Titre$, Defaut$, X%, Y%)

Le paramètre Prompt$ est le texte saisi par l’utilisateur. Vous pouvez utiliser les caractères Chr$(13) + Chr$(10) pour forcer une ligne.(comme dans MsgBox) Le paramètre Titre$ contient éventuellement le titre de la boîte de dialogue. Le texte Defaut$ est proposé au moment de l’ouverture de la boîte de dialogue. X% et Y% permettent de positionner la boîte, en l' absence de ces valeurs, la boîte de dialogue est centrée

Titre$ = "Saisie du mot de passe"

Message$="Tapez quelque chose pour accéder au programme"


Mr Y. Safsouf 26/39

MotDpass$=InputBox$(Message$, Titre

If MotDpass$ = "IGA Marrakech" Then

'Instructions (autoriser l'accès)

Else

'Instructions (refuser l'accès et quitter le programme)

End If

5. Gestionnaire d’erreurs

5.1 Erreur d'exécution

Erreur survenant lors de l'exécution du code. Une erreur d'exécution se produit lorsqu'une instruction tente d'accomplir une opération non valide. Nous avons tous utilisé dans notre activité de développement l’instruction :

On Error Resume Next

C'est en effet une instruction intéressante car si une erreur se produit, le programme ignore l'erreur et passe à la ligne suivante. Mais, à mon avis c’est une instruction que l’on doit insérer dans son programmes que lorsque l’on a débugué son application et pour prévenir l'erreur imparable que l’on n'avait pas prévue lors des divers contrôles des lignes de code. Le gestionnaire d’erreurs sert à fournir à l’utilisateur les possibilités de récupérer proprement les erreurs d’exécutions du programme. Vous utilisez généralement l'instruction Resume lorsque le gestionnaire d'erreurs peut corriger une erreur et l'instruction Resume Next dans le cas contraire. Vous pouvez cependant écrire un gestionnaire d'erreurs qui ne révèle pas à l'utilisateur l'existence d'une erreur d'exécution ou qui affiche des messages d'erreur tout en permettant à l'utilisateur de saisir des corrections. La base de votre gestionnaire d' erreurs est l' instruction On Error : On Error GoTo SortieDiscrete (L' étiquette qui suit le mot clé On Error GoTo est laissée libre à votre discrétion)

On Error Resume Next

On Error GoTo 0

Quand Visual Basic traite l’instruction On Error, il initialise un traitement d’événements qui vérifie continuellement les conditions d’erreurs pendant que le code s’exécute. Quand une erreur se produit, le chemin précis du déroulement du programme dépend de l'utilisation de l’instruction On Error. La liste suivante montre les différentes expressions de cette instruction On Error GoTo suivi de l'étiquette que vous avez déclarée, en l'ocurence dans cet exemple, nous emploierons : On Error GoTo SortieDiscrete : le contrôle passe à la première ligne exécutable du code qui suit l’étiquette indiquée par SortieDiscrete.

Exemple :

Private Sub Form_Load()

On Error GoTo Sortiediscrete

Exit Sub

SortieDiscrete:

msg = "Une erreur involontaire s' est produite"

msg + msg = " veuillez relancer le programme!"

MsgBox msg

End Sub


Mr Y. Safsouf 27/39

Explications : Vous avez indiqué au programme que, s’il rencontre une erreur, qu'il veuille bien se diriger vers l'étiquette réservée à cet effet. 1er cas, il y a effectivement dans le listing du code une erreur inconnue provoquée par le programme ou par le système, dés que l' erreur est détectée, le contrôle est dirigé automatiquement vers l' étiquette Label, dans notre cas, c' est l' étiquette "Sortie discrète". Il l’ignore mais lit les lignes de codes qui suivent immédiatement celle-ci. Si vous n' avez pas de message, le programme suit son cours, si vous avez un message, il le lit, ferme la page en cours, termine son cycle et attend les instructions suivantes. Deuxième cas, il n' y a pas d'erreurs, le contrôle lit les lignes de code, arrive à l'instruction Exit Sub, ferme normalement la page en cours, sort de la procédure et attend de nouvelles instructions. Si nous n'avions pas mis l'instruction Exit Sub le contrôle aurait continué à lire les instructions suivantes et aurait affiché les les lignes de code qui se trouvent après l’étiquette Label ce qui vous aurait induit en erreur. Vous avez constaté que j'ai mis juste après l' étiquette le double point ":", c'est tout simplement la caractère qui indique à VB que j' ai utilisé une étiquette de renvoi. On Error Resume Next : Le contrôle passe à la ligne qui suit celle qui a provoquée l'erreur. On Errot GoTo 0 : L'erreur est neutralisée et le gestionnaire d'erreurs est contourné dans la procédure. Le code suivant montre l'utilisation d'un gestionnaire simple pour contrôler la suppression d'un fichier LANGLADE.TXT sur le lecteur de disquette.

Sub Main( )

On Error GoTo InformeMoi

Kill "A:\LANGLADE.TXT"

Exit Sub

InformeMoi:

MsgBox "Erreur de lecture de disquette"

End sub

5.2 Les propriétés de l’objet ERR

Une fois que l' exécution du programme a été transmise à votre routine de gestion d' erreurs, votre code peut déterminer l' erreur qui s' est produite en affichant son numéro et sa description. Quand une erreur se produit, les informations la concernant sont stockées dans l' objet ERR. Vous pouvez utiliser deux propriétés de cet objet, la propriété Number et la propriété Description. Dans les vieilles versions du Basic, les instructions Error et Error() étaient utilisées.

• Err.Number : indique le numéro de l’erreur • Err.DEscription : indique la description de l’erreur

Le code qui suit montre un exemple de code qui vérifie l'existence d' un fichier dans un répertoire particulier. En cas d’erreur, le programme affiche le numéro de l’erreur ainsi que sa description.

Sub Main ( )

On Error GoTo ErreurFatale

If Dir ("C:\Gilou\Langlade.txt") = False Then

MsgBox "Ce fichier n' existe pas"

End If

Exit Sub

ErreurFatale:

MsgBox "N° erreur:"&Err.Number & vbLf & Err.DEscription

End Sub

La figure qui suit montre le résultat obtenu issu de la capture de l' erreur par le gestionnaire.


Mr Y. Safsouf 28/39

Le gestionnaire d’erreur permet d’afficher le numéro de l’erreur et sa description.

Vous pouvez utiliser toutes les valeurs disponibles en consultant l' aide en ligne de visual Basic en appuyant sur la touche F1 de votre clavier.

VIII. Création des menus (contrôle) Un contrôle Menu affiche un menu personnalisé pour votre application. Un menu peut inclure des commandes, des titres de sous-menus et des barres de séparation. Vous pouvez créer des menus dans lesquels figurent jusqu'à quatre niveaux de sous-menus. Pour créer un contrôle Menu, utilisez le Créateur de menus. Entrez le nom du Menu dans la zone Caption. Pour créer une barre de séparation, tapez simplement un trait d'union (-) dans la zone Caption. Pour afficher une coche à gauche du nom d'un élément de menu, activez la case à cocher Checked.

1. Créateur de menus, boîte de dialogue – (voir TP 9.1)

Bien que certaines propriétés des contrôles Menu puissent être définies dans le Créateur de menus, toutes les propriétés de ces contrôles sont disponibles dans la fenêtre Propriétés. Pour afficher les propriétés d'un contrôle de Menu, sélectionnez son nom dans la zone Objet de la partie supérieure de la fenêtre Propriétés.

2. Options de la boîte de dialogue

Caption : Vous permet d'entrer les noms de menu ou de commande qui apparaîtront sur votre barre de menus ou dans un menu. Si vous voulez créer une barre séparatrice dans votre menu, tapez un simple trait d'union (-) dans la zone Caption. Pour permettre à l'utilisateur d'accéder au menu par l'intermédiaire du clavier, insérez un caractère (&) avant une lettre. Au moment de l'exécution, cette lettre apparaît soulignée (le caractère & reste invisible), et l'utilisateur peut accéder au menu ou à la commande en appuyant sur ALT et la lettre. Si vous souhaitez qu'un caractère & apparaisse dans le menu, tapez deux caractères & consécutifs dans la légende.


Mr Y. Safsouf 29/39

Name : Vous permet d'entrer un nom de contrôle pour l'élément de menu. Ce nom est un identificateur utilisé uniquement pour accéder à l'élément de menu dans le code. Il n'apparaît pas dans le menu. Index : Vous permet d'affecter une valeur numérique qui détermine la position du contrôle à l'intérieur d'un groupe de contrôles. Cette position n'a aucun rapport avec la position à l'écran. ShortCut : Vous permet de sélectionner un raccourci clavier pour chaque commande. HelpContextID : Vous permet d'affecter une valeur numérique unique pour l'identificateur de contexte. Cette valeur est utilisée pour trouver la rubrique appropriée dans le fichier d'aide identifié par la propriété HelpFile. NegotiatePosition : Vous permet de sélectionner la propriété NegotiatePosition du menu. Cette propriété détermine si le menu apparaît dans une feuille conteneur, et, si oui, à quel emplacement. Checked : Vous permet d'ajouter une coche à la gauche d'un élément de menu. Celle-ci est généralement utilisée pour signaler si une option à bascule est validée ou non. Enabled : Vous permet de décider si l'élément de menu doit répondre à des événements, ou doit être grisé si vous voulez qu'il soit indisponible. Visible : Vous permet de rendre l'élément visible dans le menu. WindowList : Détermine si le contrôle Menu contient une liste des feuilles MDI fille ouvertes dans une application MDI.

Flèche vers la droite : Déplace le menu sélectionné d'un niveau vers le bas lorsque vous cliquez dessus. Vous pouvez créer jusqu'à quatre niveaux de sous-menus.

Flèche vers la gauche : Déplace le menu sélectionné d'un niveau vers le haut lorsque vous cliquez dessus. Vous pouvez créer jusqu'à quatre niveaux de sous-menus.

Flèche vers le haut : Déplace l'élément de menu sélectionné d'une position vers le haut à l'intérieur d'un même niveau de menu à chaque fois que vous cliquez dessus.

Flèche vers le bas : Déplace l'élément de menu sélectionné d'une position vers le bas à l'intérieur d'un même niveau de menu à chaque fois que vous cliquez dessus.

3. Zone de liste du menu

Zone de liste qui affiche une liste hiérarchique des éléments de menu. Les éléments de sous-menus sont indentés pour indiquer leur position ou leur niveau hiérarchique. Suivante : Déplace la sélection vers la ligne suivante. Insérer : Insère une ligne dans la liste, au-dessus de la ligne actuellement sélectionnée. Supprimer : Supprime la ligne actuellement sélectionnée. OK : Ferme le Créateur de menus et applique toutes les modifications à la dernière feuille sélectionnée. Le menu est disponible au moment de la création ; toutefois le fait de sélectionner un menu à la création ouvre la fenêtre Code pour l'événement Click de ce menu, sans exécuter aucun code d'événement. Annuler : Ferme le Créateur de menus et annule toutes les modifications.

4. Apprenons à réaliser des barres de menu dans notre interface.

Donnons le "Focus" à notre feuille de travail en la sélectionnant tout simplement, la barre de titre s'affiche avec la couleur bleu que vous connaissez bien. Cliquez dans la barre de menu de V.B sur l'étiquette "Fenêtre" puis sur l'étiquette "Création de menus". Ou bien. Dans la barre d’outils de l' interface de VB, cliquez sur l' icône qui représente

un fichier le troisième en partant de la gauche. (Il est nécessaire qu' une feuille soit affichée). Vous visualisez le créateur de menu.


Mr Y. Safsouf 30/39

• La fenêtre de création de menus s'ouvre. • 1ére étiquette - l'étiquette intitulée "Fichier" ( Etiquette Parent )

o Dans la propriété "Caption" o Ecrire : [&Fichier] (sans les [ ] ) puis appuyez sur la touche tabulation ( Tab) de

votre clavier o votre curseur se positionne dans le champs de saisie intitulé "Name" o Ecrire : [mnu_Fichier], dans la propriété "Name", appuyez sur Tab(bouton clavier)

• 1ére sous étiquette - l'étiquette "Imprimer" ( Etiquette Fille ) o Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie. o Ecrire : [&Imprimer] dans la propriété "Caption" appuyez sur Tab, puis, o Ecrire : [mnu_Print], dans la propriété "Name", appuyez sur Tab,

Ensuite cliquez sur le bouton flèche droite pour créer une étiquette fille qui sera logée dans l'étiquette (Parent) intitulée "Fichier"

• 2éme sous étiquette - l'étiquette intitulée "Exécuter" (Etiquette Fille ). Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie.

o Ecrire : [&Exécuter] dans la propriété "Caption" appuyez sur la Tab puis, o Ecrire : [mnu_Execut, dans la propriété "Name", appuyez sur Tab. Si les quatre

petits points avant la commande &Executer ne sont pas représentés alors, cliquez sur le bouton flèche droite pour créer une étiquette fille qui sera logée dans l'étiquette (Parent) intitulée "Fichier" sinon,

o Insérer une ligne de séparation (Etiquette Fille) o Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie. (les 4

petits points s'inscrivent automatiquement) o Ecrire : [-] (tiret de séparation situé sur la touche "6" de votre clavier) dans la

propriété " Caption ", appuyez sur "Tab" o Ecrire : [mnu_Sep1, dans la propriété "Name", appuyez sur Tab

• 3éme sous étiquette - l'étiquette intitulée "Quitter" (Etiquette Fille) o Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie. o Ecrire : [&Quitter] dans la propriété "Caption" appuyez sur la Tab puis, o Ecrire : [mnu_Quitter, dans la propriété "Name", appuyez sur Tab

• 2éme étiquette - l'étiquette intitulée "?" (Etiquette Parent) o Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie. o Ecrire : [?] dans la propriété "Caption" appuyez sur la Tab puis,


Mr Y. Safsouf 31/39

o Ecrire : [mnu_About_Titre, dans la propriété "Name", appuyez sur Tab ( observez que devant le caractère " ? " nous n'avons pas les 4 petits points ( étiquette Parent )

• 1ére sous étiquette - l'étiquette intitulée "A propos de..." ( Etiquette Fille ) o Appuyez sur le bouton " Suivant" pour ouvrir une nouvelle fenêtre de saisie. o Ecrire : [&A propos de...] dans la propriété "Caption" appuyez sur la Tab puis, o Ecrire : [mnu_About, dans la propriété "Name", appuyez sur Tab

ensuite cliquez sur le bouton flèche droite pour créer une étiquette fille qui sera logée dans l'étiquette (Parent)

o Appuyer sur le bouton "OK", contrôlez votre travail et sauvegardez le.. Vous avez écrit votre première " barre de menus"

IX. Gestion des fichiers On n’abordera pas ici la manière dont on peut attaquer des fichiers complexes (comme des bases de données), via des contrôles ad hoc. Ce point a été délibérément zappé du cours, pour des questions de temps et de redondances avec d’autres matières. Ce petit chapitre a pour but plus limité, de vous fournir un outil simple et universel pour stocker et récupérer des données d’une exécution à une autre, au travers d’un genre de fichier qu’on a déjà dû vous présenter amplement en C : le fichier texte à accès séquentiel. On peut également accéder aux fichiers en "accès direct" ; il existe aussi des fichiers dits "binaires", mais il faut faire vite, et on se concentrera ici sur le type le plus basique (mais pas le moins utile). Pour plus de précisions, il n’est pas interdit de zieuter attentivement sur la gestion de fichiers un excellent cours d’algorithmique que je recommande vivement à ceux qui ne le connaissent pas..

1. Ouvrir et fermer un fichier – (voir TP 10.1, TP 10.2)

Pour ouvrir un fichier, vous devez connaître son nom (y compris le chemin d’accès), dire ce que vous voulez en faire (lire, écrire, ou ajouter ?) et lui attribuer un numéro arbitraire, dit numéro de canal. Cela donnera ainsi :

Open "C:\TextFile.txt" For Input As #1

Bien sûr, si vous utilisez plusieurs fichiers simultanément, il est impératif de leur attribuer chacun un numéro de canal différent… For Input signifie qu’on ouvre le fichier en lecture. Pour l’ouvrir en écriture, on utilisera For Output, et pour l’ouvrir en ajout, For Append. Rappel : à l'ouverture, il faut choisir, on ne peut faire qu’une seule chose à la fois avec un fichier. Et puis tant qu'on y est, et d'un même élan sublime, voici l'instruction de fermeture d'un fichier :

Close #i

Où i est le numéro de canal du fichier à fermer.

2. Lire un fichier

Il y a trois possibilités. Deux que je ne cite que pour l’anecdote, car mieux vaut les éviter, et une vraiment utile. Pour l’anecdote uniquement, donc :

NomDeVariable = Input (100, #i)

...recopie dans NomDeVariable les 100 caractères suivants du fichier numéro i, à partir de la dernière lecture. Sinon, on peut aussi faire :

Toto = LOF(#i)

Input (Toto, #i)

Toto récupère ici le nombre de caractères du fichier texte, via la fonction LOF. On recopie ensuite tout le fichier d’un seul coup d'un seul dans la variable NomDeVariable. Mais l'avantage des fichiers texte étant d'être organisés par lignes, c'est-à-dire par enregistrements, voilà ce qu’il faut utiliser afin de ne pas perdre cette structuration :

Line Input #i, NomDeVariable


Mr Y. Safsouf 32/39

C’est de loin la meilleure solution. Elle suppose toutefois que le fichier texte soit correctement construit, c’est-à-dire que chaque série de champs se termine par les caractères CR LF, formant ainsi une ligne (vous n’avez pas besoin de vous tracasser pour cela, si vous avez vous-mêmes correctement créé le fichier texte). A ce moment-là, chaque lecture avec Line Input copie la ligne suivante du fichier dans NomDeVariable. Si vous avez eu de surcroît la bonne idée de bâtir votre fichier sous forme de champs de largeur fixe, ce sera un jeu d'enfants de récupérer, au sein de chaque ligne, les différents champs. D'une manière ou d'une autre, il suffira de découper à un moment ou à un autre NomDeVariable en différents morceaux via la fonction Mid (on aura soin d’épurer les espaces inutiles grâce à la fonction Trim mentionnée précédemment. Je rappelle qu'avec les fichiers, la technique standard consiste à balancer d'entrée de jeu l'intégralité du fichier en mémoire vive, autrement dit dans un tableau (on évite de faire cela uniquement si le fichier est vraiment trop massif pour tenir en mémoire, ce qui est un cas très rare). En revanche, pour le détail, on peut opter pour plusieurs options : soit "casser" d'entrée chaque ligne du fichier en différents champs qui rempliront différents tableaux, soit tout envoyer dans un seul tableau, à raison d'une ligne complète par élément du tableau, ligne dont on extrait ensuite les champs au fur et à mesure des besoins. C'est au choix du client. Cette seconde technique donnera, extrêmement classiquement, les lignes de code suivantes :

Dim T() as string

...

Open "C:\Monfichier.txt" As #1 For Input

i = -1

While Not Eof(1)

i = i + 1

Redim Preserve T(i)

Line Input #1, T(i)

Wend

Le principe est simple : on crée un tableau dynamique. On parcourt le fichier ligne après ligne tant qu'il en reste (boucle While ... Wend). A chaque ligne, on actualise l'indice i, on redimensionne le tableau, et on recopie la ligne dans la nouvelle case ainsi créée, tout en préservant les cases précédemment remplies. Et hop.

3. Ecrire dans un fichier

Là, c'est carrément du gâteau. L'écriture se fait systématiquement ligne par ligne. L’instruction à utiliser est :

Print #i, NomDeVariable

…qui écrit donc le contenu de la variable NomDeVariable dans le fichier de numéro i. Encore une fois, pour être certain que les différentes informations sont rangées en respectant les champs de largeur fixe, le plus simple aura été de déclarer certaines variables String comme possédant toujours un nombre fixe de caractères. Par exemple, en ayant déclaré :

Dim Nom as String*25

Je le répète, j’ai créé une variable caractère Nom qui, quoi qu’il arrive dans la suite du code, possédera toujours 25 caractères exactement. Je constituerai donc une ligne du fichier (la variable caractère NomDeVariable) par concaténation de différentes variables caractères de largeur fixe, et j’enverrai ensuite cette ligne dans le fichier par un Print. Ainsi, on est certain de respecter la structure du fichier et de pouvoir réutiliser celui-ci la fois suivante. Si l'on a choisi la meilleure solution, à savoir utiliser les variables structurées, il reste tout de même un petit souci. C'est que si VB autorise la lecture d'une ligne dans une variable structurée, il interdit la recopie directe d'une variable structurée dans un fichier texte. C'est énervant, mais c'est comme ça. Cette recopie devra donc se faire sous forme de concaténation de champs, par exemple :

Print #2, T(i).Nom & T(i).Prenom & T(i).Tel


Mr Y. Safsouf 33/39

X. Accès aux Données (Data contrôle / DAO / ADO) En Visual Basic, plusieurs méthodes d'accès aux bases de données sont proposées au programmeur :

• Le contrôle "Data" : simple d'utilisation, pour les programmes les moins évolués qui accèdent aux bases de données le plus souvent locales,

• D.A.O (Data Access Object) : très utilisé pour l'accès aux bases de données locales, • A.D.O (Active X Data Object) : très utilisé pour l'accès aux bases de données distantes.

1. Utilisation du contrôle DATA (DATA CONTROL)

Le contrôle "Data" est disponible dans la boîte à outil standard. Il permet de se connecter aux bases de données de types Jet ou ODBC. La première chose à faire est de déposer un contrôle Data sur la Form. Ensuite, il faut renseigner un certain nombre de propriétés :

• Name : nommer le contrôle Data (ou conserver son nom par défaut). • Databasename : permet de spécifier le chemin et le nom de la base de données à ouvrir. • Recordsource : permet de spécifier le nom de la table.

Une fois ces propriétés renseignées, l'accès à la base est établie. Certaines propriétés permettent de modifier les paramètres du contrôle Data. Les principales propriétés sont :

• Connect : Type de base de données à ouvrir (Access, Excel …). • DefaultType : Définit si la base de données est de type Jet ou ODBC. • RecordsetType : Type d'objet recordset (encore appelé jeux d'enregistrements). • Visible : Définit si le contrôle Data est visible ou non sur la feuille en mode exécution.

Une fois la connexion à la base de données établie, il reste à afficher les jeux d'enregistrements (ou recordsets) à l'aide de TestBox. En effet, le contrôle TextBox disposent de propriétés le permettant d'être lié à un contrôle Data et donc à une base de données. Ces propriétés sont :

• DataSource : Spécifie le nom du contrôle Data permettant l'accès à la base de données. • DataField : Spécifie le nom du champs dont on affiche la valeur.

Il suffit d'utiliser autant de TextBox qu'il n'y a de champs pour pouvoir afficher la totalité des jeux d'enregistrements. Utilisez les flèches du Data Control pour faire défiler les enregistrements. Du fait que la TextBox est liée au Data, son affichage est actualisé automatiquement à chaque déplacement dans le jeu d'enregistrements.

2. D.A.O (DATA ACCESS OBJECT) – (voir PDF_DAO, Article_DAO, TP 11.1)

Pour utiliser le modèle D.A.O, il faut ajouter une référence au projet, c'est à dire ajouter la bibliothèque d'objets correspondante. Pour cela cliquez sur "Références" dans le menu contextuel "Projet". Cochez la bibliothèque d'objets "Microsoft D.A.O Object Library" puis cliquez sur "Ok" pour ajouter la bibliothèque au projet. Exemple : On a une base de données Jet située à la racine du disque dur, elle se nomme "BD1.mdb". Elle contient deux tables : "Personne" et "Métier"

2.1 – Déclaration de la base de données

La première chose à faire est de déclarer la base dans le programme. Dim MaBase as DataBase

(MaBase est le nom que je donne à la base dans mon programme).

2.2 – Déclaration des jeux d'enregistrements ou recordsets

Il est conseillé de créer autant de jeux d'enregistrements qu'il y a de tables et requêtes dans votre base de données.

Dim PersonneRst as Recordset

(PersonneRst est le nom que je donne à mon recordset dans mon programme). Dim MétierRst as Recordset


Mr Y. Safsouf 34/39

(MétierRst est le nom que je donne à mon recordset dans mon programme).

2.3 – Ouverture de la base de données

Le plus souvent, on ouvre la base dans la procédure événementielle "Form_Load". Set MaBase = OpenDatabase ("C:\BD1.mdb")

MaBase est le nom avec lequel j'ai déclaré ma base de données.

2.4 - Affectation des tables aux recordsets Set PersonneRst = MaBase.OpenRecordset ("Personne")

Set MétierRst = MaBase.OpenRecordset ("Métier")

PersonneRst et MétierRst sont les noms avec lesquels j'ai déclaré mes recordsets Il existe différents types de jeux d'enregistrements, ils sont décris plus bas dans la section "type d'enregistrements". Ici on ne précise rien, c'est donc le type par défaut qui est utilisé "Table" pour une base de données de type Access et "Forward Only" pour une base de donnée de type ODBC.

2.5 - Navigation dans le jeu d'enregistrements

Comme on n'utilise plus de contrôle Data, les boutons de navigations dans les jeux d'enregistrements sont à créer par les développeurs. Pour cela, on va créer des boutons de commandes dans lesquels on va placer les instructions suivantes (RecordsetRst est le nom du jeu d'enregistrement) :

• RecordsetRst.MoveNext : Aller à l'enregistrement suivant • RecordRst.MovePrevious : Aller à l'enregistrement précédent • RecordRst.MoveFirst : Aller au premier enregistrement • Recordset.MoveLast : Aller au dernier enregistrement • Recordset.Move + n : Déplacer de n enregistrements (n entier positif ou négatif)

Exemple : on crée un bouton appelé CmdSuivant dans lequel on va placer l'instruction "PersonneRst.MoveNext" sur l'événement clique, puis un bouton CmdPrécédent … Les propriétés BOF (Begin Of File) et EOF (End Of File) respectivement début de fichiers et fin de fichiers, retournent vrai si on a atteint le premier ou le dernier enregistrement (selon le cas). Exemple :

If PersonneRst.EOF = True then

Beep 'Emission d'un bip sonore si on atteint le dernier

End if

2.6 - Affichage des enregistrements

Comme pour l'affichage des recordsets avec le DataControl, avec D.A.O on va également utiliser les TextBox. La différence réside dans le fait que l'on ne va pas utiliser les propriétés de la TextBox pour la lier à la base. Par conséquent les TextBox ne seront pas actualisées lorsque l'on va se déplacer dans le jeu d'enregistrements. C'est au développeur de le programmer. Exemple : on crée une TextBox nommée "TxtNom" qui va recevoir le champs "nom" de la table "personne". A chaque fois que l'on va se déplacer dans le jeu d'enregistrements, il faudra actualiser l'affichage de la TextBox. On place donc le code suivant derrière le bouton CmdSuivant

PersonneRst.MoveNext 'Suivant

TxtNom = PersonneRst("NOM") 'Actualiser

On peut également actualiser l'affichage avec la syntaxe suivante : TxtNom = PersonneRst![NOM]

2.7 - Ajouter un enregistrement à la fin du jeu PersonneRst.AddNew 'Ajouter un enregistrement

PersonneRst![NOM] = "MARTIN" 'Ajout d'un nom

PersonneRst.Update 'Valider l'ajout


Mr Y. Safsouf 35/39

Tant que la méthode "update" n'est pas lancée, l'enregistrement n'est pas ajouté.

2.8 - Modifier un jeu d'enregistrements

D'abord, on se place sur l'enregistrement que l'on veut modifier à l'aide des méthodes de la famille "move", puis on place les instructions suivantes :

PersonneRst.Edit 'Ouverture de l'enregistrement pour modification

PersonneRst![NOM] = "MARTINE" 'Modification, ici du champs nom

PersonneRst.Update 'Mise à jour de l'enregistrement

2.9 - Annulation d'un ajout ou d'une modification

Après l'utilisation de la méthode "Addnew" ou "Edit", on peut annuler l'opération par la méthode "CancelUpdate" :

PersonneRst.AddNew 'Ajouter

PersonneRst.Cancelupdate 'Annuler

2.10 - Suppression d'un enregistrement

Un enregistrement peut être supprimé à l'aide de la méthode "Delete" : PersonneRst.Delete 'Effacer

2.11 – Compter le nombre d'enregistrements dans un jeu d'enregistrements

La propriété "RecordCount" permet de comptabiliser le nombre d'enregistrements contenus dans un jeu.

PersonneRst.Recordcount 'Retourne le nombre d'enregistrements contenus dans

le recordset "PersonneRst"

2.12 - Fermer les jeux d'enregistrements

A l'aide de la méthode "Close" : PersonneRst.Close 'Fermer

MétierRst.Close

2.13 - Fermeture de la Base de données

Egalement à l'aide de la méthode "Close" : MaBase.close 'Fermer

2.14 – Utilisation de requêtes

On ouvre une requête de la même manière qu'une table, par la ligne de codes suivante : • MaBase est le nom de déclaration de la base de données. • MétierRst est le nom du recordset.

Exemple de requête non paramétrée : Set MétierRst = MaBase.OpenRecordset ("SELECT * FROM Métier")

Exemple de requête paramétrée : Set MétierRst = MaBase.OpenRecordset ("SELECT DESIGNATION FROM METIER WHERE

CODE = '" & TxtCode & "'")

Remarques : le paramètre est fournit par la TextBox "TxtCode". Le code doit être obligatoirement encadré par des apostrophes ( ' ) puisque c'est un paramètre numérique. On doit donc utiliser l'opérateur de concaténation (&) pour concaténer la chaîne SQL et la valeur du paramètre en une expression unique.

3. A.D.O (ACTIVE X DATA OBJECT) – (voir PDF_ADO, TP 11.2)

Pour utiliser le modèle A.D.O, il faut également ajouter une référence au projet, c'est-à-dire ajouter la bibliothèque d'objets correspondante. Pour cela cliquez sur "Références" dans le menu


Mr Y. Safsouf 36/39

contextuel "Projet". Cochez la bibliothèque d'objets "Microsoft ActiveX Data Objects Library 2.1" puis cliquez sur "Ok" pour ajouter la bibliothèque. Exemple : On a une base de données Jet située à la racine du disque dur, elle se nomme "BD1.mdb". Elle contient deux tables : "Personne" et "Métier"

3.1 – Déclaration de la connexion

Avec A.D.O, on déclare une connexion à une base de données et non la base de données elle même. La première chose à faire est de déclarer la connexion à la base dans le programme.

Dim MaConnection as new ADODB.Connection

(Maconnection est le nom que je donne à la connexion).

3.2 – Déclaration des jeux d'enregistrements ou recordsets

Il est conseillé de créer autant de jeux d'enregistrement qu'il y a de tables et requêtes dans votre base de données.

Dim PersonneRst As New ADODB.Recordset

(PersonneRst est le nom que je donne à mon recordset dans mon programme). Dim MétierRst As New ADODB.Recordset

(MétierRst est le nom que je donne à mon recordset dans mon programme).

3.3 – Définition du Provider

Avec A.D.O, on peut ouvrir tous type de base à condition d'en détenir le Provider. Celui de Access est : "Microsoft.jet.OLEDB.4.0". L'instruction :

MaConnection.Provider = "Microsoft.jet.OLEDB.4.0"

Permet de définir le provider pour Access (MaConnection étant le nom de la connexion).

3.4 – Ouverture de la connexion

Le plus souvent, on ouvre la connexion dans la procédure événementielle "Form_Load". MaConnection.Open ("data source = C:\bd1.mdb")

MaConnection est le nom avec lequel j'ai déclaré ma connexion à la base de données. Avec ADO, il aussi possible d'accéder à des bases de données dont l'accès est autorisé par mot de passe. Dans ce cas, il faut spécifier le nom utilisateur (Username) et son mot de passe (Password) lors de l'ouverture de la base de données. MaConnection.Open (source, username, password)

MaConnection.Open ("data source=c:\bd2.mdb","Laurent","LD1980")

3.5 - Affectation des tables aux recordsets

Recordset.Open (source, nom connexion, cursor type, Lock type) • Source: Requête SQL • nom connexion: le nom avec lequel j'ai déclaré ma connexion à la base de données • cursor type: type des jeux d'enregistrements :

o dbOpenDynamic : Ouverture Dynamique o dbOpenKeyset : En mode Feuille de réponse dynamique o dbOpenStatic : Ouverture Statique o dbOpenForwardOnly : En avant seulement

• Lock type: Dans un environnement Multi-Utilisateurs, lorsque l'on ouvre un jeu d'enregistrements, on peut choisir un mode de verrouillage. Cela permet d'empêcher les autres utilisateurs de modifier, en même temps que vous, le même enregistrement. Il existe plusieurs modes de verrouillage :

o adLockReadOnly : Lecture seule o adLockPessimistic : Verrouillage pessimiste o adLockOptimistic : Verrouillage optimiste o adLockBatchOptimistic : Mise à jour par lots


Mr Y. Safsouf 37/39

RS.Open ("SELECT * FROM MEtier", cn, adOpenDynamic, adLockOptimistic)

3.6 - Navigation dans le jeu d'enregistrements

Comme on n'utilise plus de contrôle Data, les boutons de navigations dans les jeux d'enregistrements sont à créer par les développeurs. Pour cela, on va créer des boutons de commandes dans lesquels on va placer les instructions suivantes (RecordsetRst est le nom du jeu d'enregistrement) :

• RecordsetRst.MoveNext : Aller à l'enregistrement suivant • RecordRst.MovePrevious : Aller à l'enregistrement précédent • RecordRst.MoveFirst : Aller au premier enregistrement • Recordset.MoveLast : Aller au dernier enregistrement • Recordset.Move + n : Déplacer de n enregistrements (n entier positif ou négatif)

Exemple : on crée un bouton appelé CmdSuivant dans lequel on va placer l'instruction "PersonneRst.MoveNext" sur l'événement clique, puis un bouton CmdPrécédent … Les propriétés BOF (Begin Of File) et EOF (End Of File) respectivement début de fichiers et fin de fichiers, retournent vrai si on a atteint le premier ou le dernier enregistrement (selon le cas).

If PersonneRst.EOF = True then

Beep 'Emission d'un bip sonore si on atteint le dernier

End if

3.7 - Affichage des enregistrements

Comme pour l'affichage des recordsets avec le DataControl, avec A.D.O on va également utiliser les TextBox. La différence réside dans le fait que l'on ne va pas utiliser les propriétés de la TextBox pour la lier à la base. Par conséquent les TextBox ne seront pas actualisés lorsque l'on va se déplacer dans le jeu d'enregistrements. C'est au développeur de le programmer. Exemple : on crée une TextBox nommée "TxtNom" qui va recevoir le champs "nom" de la table "personne". A chaque fois que l'on va se déplacer dans le jeu d'enregistrements, il faudra actualiser l'affichage de la TextBox. On place donc le code suivant derrière le bouton CmdSuivant.

PersonneRst.MoveNext 'Suivant

TxtNom = PersonneRst("NOM") 'Actualiser

On peut également actualiser l'affichage avec la syntaxe suivante : TxtNom = PersonneRst![NOM]

3.8 - Ajouter un enregistrement à la fin du jeu PersonneRst.AddNew 'Ajouter un enregistrement

PersonneRst![NOM] = "MARTIN" 'Ajout d'un nom

PersonneRst.Update 'Valider l'ajout

Tant que la méthode "update" n'est pas lancée, l'enregistrement n'est pas ajouté.

3.9 - Annulation d'un ajout

Après l'utilisation de la méthode "Addnew", on peut annuler l'opération par la méthode "CancelUpdate" :

PersonneRst.AddNew 'Ajout

PersonneRst.Cancelupdate 'Annuler

3.10 - Suppression d'un enregistrement

Un enregistrement peut être supprimé à l'aide de la méthode "Delete" : PersonneRst.Delete 'Effacer

3.11 – Compter le nombre d'enregistrements dans un jeu d'enregistrements

La propriété "RecordCount" permet de comptabiliser le nombre d'enregistrements contenus dans un jeu.


Mr Y. Safsouf 38/39

PersonneRst.Recordcount 'Retourne le nombre d'enregistrements contenus dans

le recordset "PersonneRst"

3.12 - Fermer les jeux d'enregistrements

A l'aide de la méthode "Close" : PersonneRst.Close 'Fermer

MétierRst.Close

3.14 – Utilisation de requêtes

On ouvre une requête de la même manière qu'une table, par la ligne de codes suivante : Recordset.Open "Instruction SQL", NomConnection, Constante d'ouverture Les constantes exprimantes le mode d'ouvertures sont détaillées dans la section "type des recordsets". Exemple d'une requête non paramétrée :

PersonneRst.Open "SELECT * FROM NOM", MaConnection, OpenForwardOnly

Exemple de requête paramétrée : MétierRst.Open ("SELECT DESIGNATION FROM METIER WHERE CODE = '" & TxtCode &

"'", MaConnection, OpenForwardOnly)

Remarques : le paramètre est fournit par la TextBox "TxtCode". Le code doit être obligatoirement encadré par des apostrophes ( ' ) puisque c'est un paramètre numérique. On doit donc utiliser l'opérateur de concaténation (&) pour concaténer la chaîne SQL et la valeur du paramètre en une expression unique.

XI. Distribuer une application 1. Attention aux images !

Ce qui suit est de la plus haute importance ! (ce qui précédait aussi, d'ailleurs). Lorsqu’on a recours dans une application VB à un fichier image (du type .bmp), par exemple, on pourrait penser qu’il suffit de poser un contrôle Image, et de définir sa propriété Picture (son contenu) en désignant l’image voulue. Malheureusement, ce n’est pas si simple. A l’exécution, il ne suffira pas en effet qu’on ait dit qu’on voulait tel fichier image dans tel contrôle. Il faudra aussi impérativement que ce fichier ait été préalablement chargé en mémoire. Dès lors, il y a deux stratégies possibles.

• on inclut directement les fichiers image dans l’application. C'est-à-dire que la propriété Picture du contrôle est réglée par défaut sur le fichier image à inclure. La conséquence est que lors de la compilation, VB repère que tel ou tel fichier image doit être inscrit dans un contrôle.

• l'autre stratégie consiste à ne pas affecter par défaut la propriété Picture des contrôles, et on utilise la fonction LoadPicture dans le code. Cette fonction a pour rôle de charger au cours de l'exécution l'image dans le contrôle, en allant chercher le fichier adéquat sur le disque dur, le CD-ROM, etc. Dès lors, l'image ne sera pas incluse dans l'exécutable. Celui-ci se contentera, lorsqu'il tombera sur cette instruction, d'aller chercher le fichier pointé par cette ligne de code.

Cette dernière technique est certes un plus difficile à mettre en oeuvre, mais c'est la seule qui assure que l'exécutable restera dans des proportions raisonnables. Elle implique deux choses :

• Premièrement, il faut écrire le code en pointant correctement sur les fichiers images qui devront être situés dans un répertoire relatif à celui de l'application. Couramment, quel que soit le répertoire de l'exécutable, on constitue par exemple un sous-répertoire "Images", dans lequel on stocke tous les fichiers images dont l'application a besoin. Le chargement des images s'accomplira via le code suivant (on suppose que le contrôle image s'appelle Tableau, et que le fichier est "VanGogh.jpg" :


Mr Y. Safsouf 39/39

Chemin = App.Path

If Right(Chemin, 1) <> "\" Then

Chemin = Chemin & "\"

Endif

Chemin = Chemin & "Images\"

Tableau.Picture = LoadPicture(Chemin & "VGogh.jpg")

• Mais, et c'est le deuxième point, pour que cette affaire continue à marcher lorsque je vais distribuer mon application sur d'autres machines, il faut que je puisse être certain que les fichiers images seront bien présents dans le bon répertoire, celui que pointe l'instruction LoadPicture (en l'occurence, dans un sous répertoire "Images" de mon application. C'est entre autres à cela que sert un indispensable utilitaire, l'installateur automatique.

2. Utiliser l’installateur automatique

Votre application est enfin terminée. Elle est blonde, elle est belle, elle sent bon le sable chaud. Elle tourne sans erreurs et sans même remuer les oreilles. Bref, vous pouvez être fiers de vous. Il ne reste plus qu'à faire profiter le reste de l'Humanité de votre Œuvre ; car ce serait trop dommage de l'en priver. Commençons par le début : vous allez compiler le projet, créant ainsi un fichier *.exe, qui sera dorénavant repéré par une jolie icône (qui n'est autre que l'icône de la Form par défaut du projet). Evitez de laisser l'icône par défaut, il n'y a rien qui fasse davantage toc d'entrée de jeu. Mais là, restent quelques détails à régler. En effet, si vous ne transmettez à quelqu'un que ce fichier exe, il risque de ne rien pouvoir en faire du tout, car peuvent vraisemblablement lui manquer :

• les bibliothèques de VB, à savoir des fichiers de type DLL auxquels l'exécutable devra s'adresser en permanence pour effectuer son travail. Sans ces bibliothèques, l'application refusera de tourner. Eh oui, un exécutable VB n'est jamais réellement autonome.

l'ensemble des fichiers "extérieurs" mais néanmoins indispensables à votre application, tels que les fichiers images vus il y a un instant, des éventuels fichiers texte, ou des sons, ou que sais-je encore, bref, tous les fichiers auxquels votre exécutable fera appel à un moment où à un autre, parce vous l'avez décidé. S'il manque l'un ou l'autre de ces ingrédients, votre exécutable tournera dans le vide durant une infime fraction de seconde et se plantera avec un long ululement d’agonie. Terrifiant spectacle. C'est pourquoi un logiciel spécial est prévu, l'assistant d'installation, qui va se charger de produire à partir de votre application un fichier apte à s'installer de manière propre sur une autre machine. Il n'y a pour ainsi dire qu'à suivre les instructions.

• Etape 1 : sélection du fichier projet • Etape 2 : choix du mode de déploiement (a priori, standard, "dossier unique") • Etape 3 : choix du lieu d'empaquetage (n'importe quel répertoire vierge fera l'affaire). Il

s'agit du répertoire de votre machine dans lequel l'assistant va écrire le résultat de son travail.

• Etape 4 : composants ActiveX : ignorez cette étape, sauf si vous avez inclus dans votre application des composants exotiques (voir partie 11).

• Etape 5 : fichiers à inclure. C'est l'étape décisive. A priori, vous devez conserver tous les fichiers déjà proposés par l'assistant (dont les fameuses DLL nécessaires, qu'il repère tout seul). Mais surtout, c'est à cette étape que vous pouvez en ajouter d'autres, en particulier ces fichiers image, fichiers textes, etc. dont vous aurez auparavant dressé la liste complète, car l'assistant ne le fera pas pour vous). Cliquez sur "Ajouter" pour inclure tous ces autres fichiers nécessaires dans le paquet cadeau à fabriquer. Et précisez bien dans quel répertoire de destination ces fichiers devront être installés.

Le résultat de tout cela est un fichier auto-extractible (de type Setup) qui produira de merveilleuses installations Windows de type tout à fait professionnelles, et surtout, qui s'exécuteront sans erreurs.

Documents

Visual Basic - data.over-blog-kiwi.comdata.over-blog-kiwi.com/0/52/16/08/201305/ob_ff678a6db59993e1415e... · Visual Basic INSTITUT SUPERIEUR DU GENIE APPLIQUE Rue Ibn Habousse -