Cours Visual Basic N°1
Les particularités du langage objet

Structure

En quoi un langage objet diffère-t-il d’un langage normal ? L’essentiel se situe au niveau de la manière dont les instructions (les procédures) sont déclenchées.

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 écrites dans cette procédure principale sont exécutées les unes après les autres, jusqu’à la fin (je passe pudiquement sous silence l’improbable hypothèse d’un arrêt prématuré pour cause d’erreur).

Dans un langage objet, une application est constituée de multiples procédures. Il n’y a donc plus (ou plus forcément) de procédure principale. Chaque procédure est liée à un événement, et sera donc automatiquement exécutée lorsque cet événement se produit (exemples d’évènements : un clic sur un bouton, un double-clic sur une image, etc.).

Ces événements sont la quasi-totalité du temps liés à des objets. Un objet est, pour simplifier, un graphique qui figure quelque part à l’écran (exemples : un bouton, une case, un " ascenseur ", une commande d’un menu, etc.)

Moralité : écrire un programme objet, c’est à 99 % définir :

1.     quels sont les objets qui figureront à l’écran

2.     ce qui doit se passer lorsque l’utilisateur agit sur ces objets via la souris ou le clavier.

A la différence d’un programme traditionnel, les instructions (en fait, les procédures liées aux différents événements possibles) ne seront donc pas toujours exécutées dans le même ordre : tout dépend de ce que fera l’utilisateur. Mais bien sûr, à l’intérieur de chaque procédure, les règles traditionnelles de programmation restent vraies.

Syntaxe

Les 20 % restant à comprendre concernent la syntaxe du langage.

A tout objet sont associées des propriétés, et des méthodes. Une propriété, c’est une caractéristique de l’objet. Une méthode, c’est une action possible sur l’objet. Les objets possibles, et pour chaque objet les méthodes et les propriétés qui s’y appliquent sont bien entendu définis par les rédacteurs de Visual Basic et non par vous. (Encore qu’un utilisateur averti de Visual Basic peut créer ses propres objets, propriétés et méthodes.

on écrit : objet.propriété

Compilation et Interprétation

Lorsqu’on écrit une application Visual Basic, on crée donc un ensemble d’objets, et les procédures qui s’y rapportent. Lorsqu’on sauvegarde cette application, Visual Basic va créer un certains nombre de fichiers.

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 (notamment les lignes de codes)

2.     Un fichier par objet Form créé. 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.

Lors de l’exécution, le langage est ce qu’on appelle " compilé à la volée ". C’est-à-dire que VB traduit vos lignes de code au fur et à mesure en langage machine, puis les exécute. Cela ralentit naturellement considérablement l’exécution, même si sur de petites applications, c’est imperceptible. Mais dès que ça commence à grossir…

C’est 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 préalable de Visual Basic.

Un projet terminé est donc un projet compilé.

Et qui, accessoirement, fonctionne sans erreurs. 

Cours Visual Basic N°2
Les objets standard (contrôles)

Les feuilles (" Form ")

Le contrôle de base, absolument universel, en Visual Basic est la feuille, en anglais, Form. Cet objet est quasiment incontournable ; on ne peut créer et utiliser d’autres contrôles que si ceux-ci font partie d’une Form. Il y a certes moyen de rendre celle-ci invisible, pour qu’on ne voie que les objets posés dessus ; mais même invisible, elle doit nécessairement exister.

A l’ouverture de Visual Basic, on vous propose d’ailleurs par défaut un objet Form.

A tout objet sont donc associées les propriétés :

Name : il s’agit du nom de l’objet tel qu’il est géré par l’application. Par défaut, VB baptise tous les objets que vous créez de très jolis noms génériques, comme Form1, Form2, Form3, Text1, Text2, Text3, etc.

Il est donc vivement conseillé, avant toute autre chose, de rebaptiser les objets que vous venez de créer afin de leur donner des noms plus évocateurs. Parce que sinon, dès que vous créerez une application d’une taille respectable, vous serez complètement paumés dans vos noms d’objet, et vous ne saurez plus qui est quoi.

Caption : il s’agit du texte (" étiquette ") associé à l’objet sur l’écran. Cette captionest donc très utile pour professionnaliser une application, lui donner un look fini, maisne joue aucun rôle dans la désignation de l’objet par l’application.

Je rappelle que dans le cas particulier d’une Form, outre ces deux " noms ", il y a le nom du fichier dans lequel elle sera sauvegardée. Cela fait donc trois " noms " pour un seul objet, noms qui chacun jouent un rôle différent ; Attention à ne pas se mélanger les pinceaux…

Style : propriété qui gère la forme générale de la Form (visible, invisible, présence ou non du menu système, tête des bordures, etc.)

Icon : propriété qui permet d’associer à la Form un fichier icône. Cette icône s’affichera dans la barre de Titre, tout en haut à gauche. Si la Form est la Form par défaut du projet, c’est également cette icône qui symbolisera votre application dans Windows. Cette propriété n’est pas du tout essentielle, mais elle fait partie des petits détails qui professionnalisent grandement le look final de votre travail.

Lorsqu’une application comporte plusieurs Form, et qu’on souhaite passer de l’une à l’autre, on dispose de deux catégories d’instructions :

Form1.Hide : masque Form1
Form1.Show : affiche Form1

Et sinon :

Form1.Load : charge Form1 en mémoire
Form1.Unload : décharge Form1 de la mémoire

Les procédures d’événements

Si vous vous souvenez de ce qu’on a vu plus haut, à chaque objet créé peuvent donc correspondre autant de procédures que d’événements possibles survenant à cet objet. En pratique, il est rare que l’on doive prévoir tous les événements. Si un événement se produit pour un objet (ex : l’utilisateur clique dessus) et qu’aucune procédure n’est attachée à cet événement, c’est très simple : il ne se passe rien !

VB gère très simplement la création – ou la modification – d’une procédure évènement liée à un objet. Lorsque l’objet est sélectionné, il suffit de faire un double-clic dessus (ou, c’est équivalent, d’appuyer sur F7). On se retrouve alors dans la fenêtre Code. La procédure gérant l’événement le plus courant pour l’objet considéré, si elle n’existait pas encore, vient d’être créée. Si elle existait déjà, cette manipulation vous amène sur elle pour modifications éventuelles.

La procédure ainsi créée se présente ainsi :

Private Sub NomObjet_Evenement()
Instructions
End Sub

Private signifie que la procédure n’est utilisable que pour la Form considérée (et pas pour d’autres objets situés sur d’autres Form, on reparlera de cela plus tard).

End Sub marque la fin de la procédure en question (mais pas la fin de l’application).

Vous remarquerez que l’événement retenu par VB comme étant le plus probable pour une Form est Load (chargement). Autrement dit, cette procédure contient tout ce que l’application doit faire au moment où la Form en question apparaît à l’écran.

Couramment, en plus du chargement (Load), les événements qu’on peut associer à une Form sont le clic, le double-clic, le déplacement de la souris, et éventuellement la frappe d’une touche au clavier.

Les boutons de commande

Il s’agit des boutons type OK, Annuler, mais dont le texte apparent (en Anglais, je le rappelle,caption) et le rôle dans une application peuvent varier à l’infini. Je ne vous étonnerai pas en vous disant que l'événement que VB considère comme étant le plus probable pour les boutons de commande est Click (en Français, clic, note du traducteur).

Les zones de texte

Ces zones (de type " text " pour VB) peuvent servir à saisir ou à afficher une information de type texte (autrement dit, cela inclut le cas où il s’agit d’un nombre). Il n’y a rien de bien particulier à signaler. La propriété essentielle d’une zone text est… text. C’est la propriété qui gère 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 type text, que nous avons appelée " Nomdefamille ". Pour mettre cette zone à blanc à l’affichage de la feuille de dialogue, on écrira tout simplement dans la procédure Form_Load () :

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

Les zones de textes possèdent également une foultitude d’autres propriétés, mais celles-ci concernent essentiellement leur présentation. Le fondamental, en l’occurrence, reste le contenu, donc la propriété text.

Parmi ces multiples propriétés, je signale :

Multiline : autorise ou non l’écriture sur plusieurs lignes
Scrollbars : fait figurer une barre de défilement horizontale ou verticale (ou les deux)
PaswordChar : crypte le texte entré sous forme d’étoiles
MaxLength : limite le nombre de caractères qu’il est possible de saisir

Les messages

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 instruction 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 des boutons standard comme 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 :

MsgBox comporte trois arguments essentiels :

• 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

Vous trouverez tous les détails concernant ces paramètres dans l’aide de VB. Un point mérite cependant qu’on s’y arrête : c’est que la syntaxe de cette fonction est, de manière un peu surprenante, la suivante :

Variable = MsgBox (arguments)

La variable, obligatoire, sert à stocker la réponse de l’utilisateur, c’est-à-dire sur quel bouton il a appuyé pour faire disparaître le message de l’écran. Le seul cas où l’on peut utiliser la syntaxe plus simple, sans utiliser de variable :

Msgbox " Toto "

… est celui où l’on souhaite une MsgBox avec seulement le bouton OK. Il n’est pas très difficile de comprendre pourquoi.

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.

Je ne saurais trop insister sur l’extrême utilité de cette fonction. Pour agrémenter vos applications sans vous embêter, bien sûr. Mais aussi à fins de débogage. N’hésitez surtout pas, dans un programme qui ne veut obstinément pas marcher, à mettre aux bons endroits des MsgBox pour faire apparaître la valeur de telle ou telle variable à un moment donné de l’exécution. Cela ne coûte pas cher et s’avère dans presque tous les cas fort utile.

Les cases

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 " ou " boutons radio " (OptionButton). Elles sont rondes et font toujours partie d’un groupe (dessiné par l’objet Frame). Ce groupe est indispensable, car au sein d’un groupe 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 qu’il faut toujours créer le groupe avant de poser des cases à l’intérieur. Sinon, la propriété la plus intéressante de ces cases est de loin celle qui nous permet de savoir si elle est cochée ou non. Cette propriété s’appelle Value.

Elle prend la valeur True ou False lorsqu’elle concerne les cases d’option, et 1 ou 0 lorsqu’elle s’applique aux cases à cocher. Sauf si on fait du VBA, auquel cas c’est True ouFalse tout le temps. Eh oui, chez Microsoft, c’est comme chez les Shadoks : pourquoi faire simple, quand on peut faire compliqué ?

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

A cette occasion, j’en profite pour mentionner la propriété Enabled (True ou False), qui rend un objet accessible ou non. Cette propriété est commune à la plupart des contrôles Visual Basic.

Les groupes de contrôles

Jusque là, nous avons toujours considéré que chaque contrôle était un objet complètement indépendant de ses congénères. Cela se manifestait de deux manières :

• d’une part, lors de leur création, nous allions toujours chercher l’objet dans la boîte à outils, en nous abstenant soigneusement de procéder à des copier coller.
• D’autre part, chaque objet possédait une propriété Name bien à lui qui nous permettait de le désigner sans ambiguïté en écrivant le code.

En fait, cela était la conséquence directe de ceci.

Mais cela induit lors de certains programmes une lourdeur qui ne vous aura pas échappé. Lorsque plusieurs objets de même type remplissent des tâches voisines, voire semblables, on se retrouve avec des procédures (une par objet) qui se ressemblent beaucoup, voire qui sont carrément les mêmes.

La création d’un groupe de contrôles a pour but d’alléger tout ceci. Comment ça marche, me direz-vous ? Eh bien voici, vous répondrai-je.

Lors de la création des contrôles (mettons, une série de quatre cases à cocher), on procède dorénavant par copier coller. A la question " souhaitez-vous créer un groupe de contrôles ", on répond sans réserves (mais sans illusions) par l’affirmative.

Dès lors, les quatre objets ainsi créés seront en fait des membres d’un même groupe de contrôles (on parle aussi de " collection " d’objets). En bon français, cela signifie que ces quatre objets porteront le même nom (Name) mais que ce nom sera flanqué d’une variable (on parle souvent alors d’index), variable qui servira à les identifier individuellement.

Si j’osais une métaphore ailée (mais non filée), je dirais que l’objet est à la collection d’objets ce que la variable simple est au tableau. Limpide, non ?

Donc, résumons nous. Si on a créé un groupe de 4 contrôles de type Checkbox, le nom par défaut de ce groupe sera Check1. Rebaptisons-le CaseCarrée pour plus de clarté. On aura alors CaseCarrée(0), car ça commence à zéro (faudrait pas que ce soit trop simple non plus), CaseCarrée(1), CaseCarrée(2) et CaseCarrée(3).

Si on a un traitement à effectuer sur les quatre cases, on pourra dorénavant faire une boucle, par exemple pour décocher tout ça :

For i = 0 to 3
CaseCarrée(i).Value = 0
Next i

Et voilà.

Déjà, on se marre bien. Mais c’est encore plus rigolo quand on crée la procédure associée à ce groupe. Cela produit un intitulé du genre :

Private Sub CaseCarrée_Click (Index as Integer)
End Sub

Eh oui, dorénavant, il n’y a plus qu’une seule procédure pour tout le groupe ! Si on a besoin de savoir quelle case a été cliquée, il suffit de tester au sein de cette procédure la variable Index, qui, vous l’aurez deviné, peut valoir de zéro à trois. Si le nom de variableIndex vous semble trop lourdingue, rien ne vous interdit de le modifier.

Moralité, en VB, c’est comme pour tout le reste, pour pouvoir être fainéants, devenons compétents.

Les Listes

1 les types de liste

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 proprement dites. Graphiquement, cela se traduit par la présence d’une zone de texte fonctionnant en symbiose avec la liste.

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.

VB fournit deux contrôles de liste : une liste dite simple (ListBox) et une liste dite modifiable (ComboBox). Le gag (ce Bill Gates, quand même, quel marrant), c’est qu’en réalité, la liste dite modifiable est 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	Combo Box Style = 2
Modifiable	ComboBox Style = 1	ComboBox Style = 0 (défaut)

Les listes possèdent des tas de propriétés et de méthodes intéressantes. On retiendra :

AddItem (méthode) ajoute un élément à une liste en spécifiant son rang
Clear (méthode) efface tous les éléments d’une liste
List (propriété)renvoie en clair un élément d’une liste en fonction de son index
ListCount (propriété) renvoie le nombre d’éléments d’une liste
ListIndex (propriété) renvoie ou définit l’index de l’élément actuellement sélectionné
Multiselect (propriété) permet la sélection multiple
RemoveItem (méthode) supprime un élément de la liste
Sorted (propriété) trie les éléments d’une liste

2 listes spéciales

Des objets de type liste assez particuliers sont ceux qui permettent la navigation dans le disque dur, les répertoires, les fichiers, etc. On trouve ainsi les objets suivants, qui reproduisent des outils familiers sous Windows :

DriveListBox :liste des lecteurs logiques disponibles
DirListBox :liste des répertoires
FileListBox :liste des fichiers existants

La présence de ces contrôles soulage votre tâche, mais ne vous épargne toutefois pas totalement d’écrire du code. Ces trois objets étant des cas particuliers de contrôle liste, s’y appliquent List, Listcount et Listindex. Vous devrez donc gérer la mise à jour de ces contrôles les uns en fonction des autres.

Pour ce faire, les propriétés suivantes sont indispensables :

Path : renvoie ou définit le chemin actuellement sélectionné dans un contrôleDirListBox
Filename : renvoie ou définit les fichiers présents dans la FileListBox

Cours Visual Basic N°3
Aspects du code Visual Basic

On approfondira ici certains aspects déjà abordés précédemment.

Pour mémoire, je rappelle que tout langage de programmation se ramène au bout du compte à la combinaison des quatre opérations suivantes :

• les opérations d’entrées – sorties
• la gestion de variables
• les tests
• les boucles

En ce qui concerne les opérations d’entrée sortie, c’est-à-dire tout ce qui relève du dialogue entre l’utilisateur et la machine, on a longuement vu les particularités d’un langage événementiel dans ce domaine. Et finalement, la plupart des choses que l’on a épluchées précédemment relevaient de cette catégorie. Conclusion, il ne nous reste que trois catégories d’instructions à examiner, plus quelques trucs que j’ai mis dans ce chapitre faute de me décider à les caser ailleurs.

La gestion de variables

1 Types de variables

En fait, nous avons un peu commencé à en faire sans le dire. A priori, Visual Basic n’oblige pas à déclarer une variable avant de s’en servir (il est toujours possible de l’obliger, par une option adéquate). Le seul problème est qu’en l’absence de déclaration, une variable va être automatiquement créée par VB dans le type le plus " souple ", autrement dit le plus gourmand en mémoire. Donc, si dans une petite application, déclarer les variables n’a pas forcément un intérêt majeur, dans un véritable projet utilisant beaucoup de variables, ne pas déclarer ses variables peut conduire à un remplissage exagéré de mémoire, donc à un ralentissement notable de l’exécution. Ajoutons que les variables indicées (tableaux) et les variables publiques (globales) doivent impérativement être déclarées quel que soit le cas de figure.

Les types de variables sont peu ou prou ceux du C (et de n’importe quel autre langage), à savoir :

Type	Contenu
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 virgule fixe
String	jusqu’à 65000 caractères

Il reste un type particulier de variable : c’est le type Variant>. Comme M.Jourdain, vous avez jusqu’ici fait du Variant> sans le savoir, puisque c’est le type par défaut lorsqu’on ne déclare pas explicitement une variable. Avantage du Variant> : il peut stocker n’importe quel type de données. Inconvénient : il prend énormément de place et ralentit l’exécution.

2 Tester le type d’une variable

Il peut arriver qu’au cours d’un programme, vous ayez besoin de savoir quel type de données est contenu par une variable de type Variant. Dans ce cas, VB met à votre disposition une série de mots-clés pouvant donner

If Tampon = vbEmpty

ou

If Tampon <> vbIntegeretc.

Vous trouverez la liste de ces vbBidule> dans l’Aide. Alors, de deux choses l’une : ou le type est satisfaisant : on peut ensuite employer cette variable Tampon comme prévu, ou basculer sa valeur dans une variable déclarée dans le type approprié. Dans le cas contraire, on envoie un message à l’utilisateur et on lui fait recommencer la saisie.

3 Portée des variables et déclarations

On a déjà un peu abordé ce problème au cours des exercices, mais voilà enfin l’exposé systématique que vous attendiez tous en haletant. Fermez la bouche et " écoutez moi bien, c’est un sujet d’examen ", comme disait un célèbre militaire.

L’existence d’une variable peut se dérouler sur trois niveaux :

• Procédure : cela veut dire que dès que l’on quitte la procédure en question, la variable disparaît, et son contenu avec elle.
• 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
• Globale : la variable est disponible et sa valeur est conservée pour toutes les procédures de l’application, quel que soit leur emplacement.

Naturellement, est-il besoin de le préciser, il ne faut pas raisonner en termes d’artillerie lourde, et déclarer toutes les variables comme globales, 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.

Pour déclarer une variable au niveau procédure : à l’intérieur de la procédure,

Dim NomVariable as Type

Pour déclarer une variable au niveau Form : 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)

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 A noter que le mot-clé Dim peut être indifféremment remplacé par Private, pour plus de clarté, paraît-il ( ?)

4 Variables indicées

On appelle aussi cela des tableaux. Ce peuvent ê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 élastique (mais cela se paye bien sûr par une perte de rapidité à l’exécution).

Pour créer un tableau de 12 entiers, on écrira :

Dim MonTableau(11) As Integer

Eh oui, le premier élément porte le numéro zéro. Ah ! Ah !

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)

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)

Les tests

Là aussi, on retombe dans les grands classiques du genre ; le fait que VB soit un langage objet n’a aucune espèce d’influence. On retrouve donc le célebrissime :

If condition then

Instructions

Else

Instructions

Endif

Il y a bien sûr quelques possibilités supplémentaires, comme le Elseif (que je déconseille généralement, chacun ses névroses) ou le Case (qui peut parfois être utile).

Les boucles

Là non plus, rien à signaler. On aura donc un grand standard, le :

While condition

Instructions

Wend

Et le :

For i = x to y step z

Instructions

Next i

Je ne m’attarde pas, puisque tout ça, je sais que vous jonglez avec comme qui rigole.

Gérer les erreurs

On sait que dans une application digne de ce nom, même lorsqu’une erreur se produit (fichier introuvable, mauvaise saisie au clavier, etc.) cette erreur ne donne pas lieu à un plantage inopiné du programme, mais qu’elle est gérée par ce programme. Cette brève section est donc consacrée aux erreurs à l’exécution, et au moyen de les prévoir (à défaut de pouvoir les empêcher).

Un objet à tout faire a été prévu : c’est Err, qui possède notamment comme propriétés :

Number le code de cette erreur, vous permettant de l’identifier
Description un rapide bla-bla sur la nature de l’erreur
Source qui vous indique l’objet à l’origine de l’erreur

Le truc consiste, au début d’une procédure susceptible d’engendrer des erreurs, à taper la ligne suivante :

On Error GoTo Etiquette

Une étiquette, c’est un sous-Titre à l’intérieur d’une procédure, se terminant par le signe " : ".

Oui, je sais, c’est une pure horreur que d’obliger les gens à mettre des GoTo dans un joli programme structuré. Mais que voulez-vous, ici, Microsoft ne nous a pas laissé le choix. L’idée est donc que si une erreur, quelle qu’elle soit, survient au cours de cette procédure, au lieu de sa planter bêtement, l’application ira gentiment rechercher l’étiquette que vous avez désignée, et exécutera son code.

Exemple :

Public Sub Totoche()

On Error GoTo Oops
Tata = 12 / 0
Msgbox Tata
Exit Sub

Oops:

Msgbox(" Diviser par zéro, c’est pas malin ! ")

End Sub

Bien sûr, ici, notre gestionnaire d’erreurs est vraiment a minima. On peut faire quelque chose de beaucoup plus fin en y testant la valeur Err.Number, et en réagissant différemment selon le code (donc le type) de l’erreur qui est survenue.

Appeler une procédure par du code

Jusqu’ici, toutes les procédures que nous avons utilisées étaient des procédures événements : leur nom était régi par des règles strictes, qui spécifiaient le déclenchement de leur exécution. Mais comme tout langage, le VB vous permet de créer des procédures traditionnelles, baptisées selon votre bon vouloir. Leur exécution sera déclenchée non par une action de l’utilisateur, mais par une instruction de votre programme. C’est donc l’équivalent VB du GOSUB cher à vos cœurs.

Je rappelle de tels appels peuvent comporter des paramètres, ou non, cela ne change rien de fondamental à l’affaire.

Un cas extrêmement classique d’utilisation de cette technique, c’est celui de l’initialisation d’une Form. Pour que cette Form soit propre, on veut que toutes les zones de textes soient vierges. Pour peu qu’on ait besoin de procéder à l’initialisation à plusieurs moments différents de notre application, au lieu de répéter à chaque fois les mêmes codes, on va créer une procédure Init() qui comportera les lignes de code nécessaires :

Private Sub Init()

Nom.Text = " "
Prénom.Text = " "
Etc.

End Sub

Pour appeler cette procédure, il suffira ensuite de passer l’instruction suivante :

Call Init()

Et le tour est joué.

Attention toutefois aux portées des procédures. Une procédure Private n’est disponible que si l’appel se situe dans la Form qui la contient. Pour qu’une procédure puisse être appelée de n’importe quelle Form, il faut qu’elle porte comme nom Public.

Procédure de démarrage

Lors du lancement de l’application, VB a besoin de savoir quelle procédure (ou quelle Form) est la procédure (la Form) par défaut. Si vous ne touchez à rien, il s’agit toujours de la première Form qui existait dans le projet.

Si vous souhaitez changer de Form par défaut, ou si vous souhaitez lancer le projet par une procédure principale indépendante de toute Form, ça se passe dans le menu Projet – Propriétés. Vous y choisissez de lancer l’application :

• en définissant la Form par défaut
• ou par une procédure principale, qui devra se obligatoirement se trouver dans un module et s’appeler Sub Main()

With… End With

Petite combine bien pratique pour éviter de répéter 15 fois la même chose :

Plutôt que d’écrire :

MyObject.Height = 100
MyObject.Caption = "Bonjour à tous"
Etc.
MyObject.Font.Color = Red
MyObject.Font.Bold = True
Etc.

On écrira :

With MyObject

.Height = 100
.Caption = "Bonjour à tous"
etc.
With .Font

.Color = Red
.Bold = True
etc.

End With

End With

Dans cet exemple mal choisi, il semble qu’on ne gagne pas tellement de place. Mais réfléchissez bien, en fait, si, dès que les et caetera sont un peu nombreux.

Un contrôle bien spécial : le Timer

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 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 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 déroule, même si l’utilisateur ne fait rien du tout.

Le contrôle Timer, toujours invisible, va générer des " tops " à une cadence choisie par le programmeur (propriété Interval, exprimée en millisecondes), pour déclencher la procédureTimer1_Timer(). Le programmeur pourra donc mettre dans cette procédure tout ce qui doit se passer sans que l’utilisateur ne fasse quoi que ce soit.

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

Cours Visual Basic N°4
Objets, propriétés et événements

Ce chapitre fourre-tout a pour but de faire un tour relativement complet des propriétés et des événements les plus utiles pour les différents objets. Bien entendu, vous avez déjà eu l’occasion de croiser un certain nombre de ces choses, mais là, vous allez repartir avec de quoi faire votre petit marché en toute quiétude.

Propriétés

On n’examinera ici que les 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, mais là, on va explorer cette histoire un peu plus systématiquement.

1 Localisation des contrôles

Tout contrôle placé sur une Form possède deux propriétés qui régissent son emplacement :

Top distance avec le haut de la Form
Left  distance avec la gauche de la Form

Il y a également deux propriétés qui règlent la taille du contrôle. Ce sont :

Width  largeur du contrôle
Height  hauteur du contrôle

Rien qu’avec ces quatre propriétés, on règle donc et la taille et l’emplacement de tout contrôle. CQFD.

2 Activation

La plupart des contrôles possèdent les propriétés suivantes, toutes booléennes :

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 la propriété Enabledest False.

Visible affiche / cache le contrôle considéré. C’est fou ce qu’on peut faire avec ce petit machin là.

Tabindex règle l’ordre de tabulation des contrôles dans la Form

3 L’objet App

Je signale en passant que votre application elle-même, dans sa totalité, est considérée comme un objet à part entière par VB. Cela implique que cet objet possède des propriétés.

L’une d’entre elles est particulièrement utile : elle vous indique quel est le chemin d’accès à votre exécutable. Donc, vous pouvez utiliser cette propriété pour aller chercher un fichier, quel que soit le répertoire dans lequel votre application a été installée.

Exemple : pour mettre un joli fond sur votre Form, vous voulez récupérer à un moment donné de l’exécution un fichier image, appelé " tronche.jpg ". Ce fichier se trouve dans le même répertoire que l’exécutable, mais a priori vous ne savez pas quel est ce répertoire. Vous écrirez donc :

Form1.Picture = App.Path & "\tronche.jpg"

Et le tour est joué.

Attention : cet exemple ne figure ici que pour montrer la propriété Path. Ne tapez pas ce genre de code dans votre application, pour une autre raison que nous examinerons au chapitre 7.5

Evénements

Je passe rapidement sur le Click et le DblClick, qui n’ont plus de secrets pour vous. Plus intéressants, car moins connus :

1 Evénements clavier

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 ouComboBox. Ceci pour contrôler au fur et à mesure la validité des caractères frappés (éliminer les 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 affectera l’événement KeyPress,KeyUp ou Keydown (voir plus loin pour le choix) au contrôle concerné
• On veut affecter, indépendamment de tout problème de saisie dans un contrôle, certaines actions à certaines touches du clavier. Ici, c’est à la Form que l’événement 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é, alors que Keydown et Keyupconsidè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.

2 Evénements souris

MouseDown et MouseUp sont deux événements détectant respectivement le fait qu’un bouton de la souris a été enfoncé ou relâché. Ces deux événements sont généralement affectés à une Form. Ils possèdent un certain nombre de paramètres, qui vous permettent de récupérer :

• quel bouton de la souris a provoqué l’événement
• l’état des touches Maj, Ctrl et Alt du clavier. Ceci permet de gérer des combinaisons alambiquées clavier + souris.
• Les coordonnées x et y désignant l’endroit où s’est produit le click.

MouseMove détecte le déplacement de la souris. Cet événement possède les mêmes paramètres que les deux événements précédents. Par ailleurs, je signale en passant que la souris en VB est considérée comme un objet ; elle possède quelques propriétés intéressantes, comme MousePointer et MouseIcon, vous permettant de gérer la physionomie du pointeur de la souris (pointeurs standards ou icônes de votre choix).

3 Gérer le glisser-déplacer : DragDrop et DragOver

Là, on peut vraiment s’amuser. Et par les temps qui courent, ce n’est pas rien. L’idée de fond est la suivante, si l’on veut permettre à l’utilisateur de manipuler, mettons un objet Image.

On commence par détecter l’événement consistant en un appui sur le bouton de la souris :Image_MouseDown(). Cela va nous permettre d’effectuer notamment deux choses :

• permettre à l’Image d’être cliquée-glissée. Ceci se fait au moyen de l’instructionImage.Drag
• définir quelle tête doit avoir l’image en cours de transport par la propriété DragIcon

Ensuite, on va gérer ce qui se passe lorsque on lâche l’image glissée sur quelque chose. Ceci va se faire dans la procédure QuelqueChose_DragDrop().

On peut également gérer ce qui arrive lorsqu’on survole le contrôle Truc, dans la procédureTruc_DragOver() 

Cours Visual Basic N°5
La 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 petit chapitre a pour seul but 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.

Il existe des fichiers dits " à accès aléatoire " et des fichiers dits " binaires ", mais il faut faire vite, et on se concentrera ici sur le type le plus ordinaire : le fichier " séquentiel ". C’est du texte ordinaire, avec généralement comme extension .txt.

Ouvrir un fichier

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

Open TextFile.txt For Input As #i

Bien sûr, si vous utilisez plusieurs fichiers, mieux vaut leur attribuer chacun un numéro différent…

For Input signifie qu’on ne veut que lire le fichier. Pour y écrire, on utilisera For Output, et pour ajouter simplement quelque chose à la fin, For Append. Autrement dit, il faut choisir, on ne peut faire qu’une seule chose à la fois.

Lire un fichier

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

MaVariable = Input (100, #i)

Met dans MaVariable les 100 caractères suivants du fichier numéro i, à partir de la dernière lecture. Sinon :

Toto = LOF(#i)
MaVariable = Input (Toto, #i)

Toto récupère la longueur du fichier texte, exprimée en caractères (fonction LOF). On met ensuite tout le fichier d’un coup dans MaVariable.

Ce qu’il faut utiliser :

LineInput #1, MaVariable

C’est de loin le plus utile, mais cela suppose que le fichier texte soit correctement organisé. C’est-à-dire que chaque ligne se termine par les caractères CR LF (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 copie la ligne suivante dans MaVariable.

Si vous avez eu la bonne idée de bâtir votre fichier sous forme de champs de longueur fixe, il vous suffit ensuite d’envoyer les bons morceaux de MaVariable dans différentes variables via la fonction Mid. Et le tour est joué !

Je ne prends pas ici la place pour vous rappeler qu’en VB, comme dans tout autre langage de programmation, il existe des fonctions permettant de traiter les chaînes de caractères. Ces fonctions sont universelles, et Mid permet de récupérer dans une chaîne, à partir du caractère numéro i, les j caractères suivants.

Si vous voulez gagner de la place (mais perdre du temps à l’exécution), vous pouvez opter pour des champs de longueur variable, donc avec un caractère de séparation. A partir deMaVariable, il faudra donc programmer une boucle pour lire un à un les caractères, détecter le caractère de séparation et envoyer tout cela dans vos variables. Bref, c’est un plan foireux.

Ecrire dans un fichier

Print #i, MaVariable

Ecrit dans le fichier i le contenu de MaVariable. 

Cours Visual Basic N°6
Quelques éléments sur les graphiques

VB étant un langage objet, donc événementiel, et la douce saison des projets n’allant pas tarder à arriver (je vois déjà éclore les premiers bourgeons), il est grand temps de s’amuser un peu et de faire des trucs qui bougent et des machins qui remuent.

Utiliser (bêtement) la méthode Print

Form1.Print " Coucou "

Va écrire en haut à gauche de la Form " Coucou " . La prochaine instruction Print provoquera une écriture juste en dessous… sauf si nous avions terminé l’instruction précédente par un point-virgule. Auquel cas, la prochaine écriture s’effectuera à la suite.

Remarque : a priori, si vous redimensionnez la Form... le texte disparaît. Cela peut être gênant. Il est facile d’y remédier : fixez auparavant la propriété AutoRedraw de la Form àTrue. Attention, cela ralentit toutefois l’application. Il y a une autre solutions possibles : gérer soi-même l’événement Paint de la Form, qui correspond à un redimensionnement…

Intéressant : Print s’applique également à un contrôle Picture. Cela représente une alternative par rapport aux modifications de Label.Caption que nous avions utilisé jusque là.

Spécifier des couleurs

Il n’y a pas moins de trois systèmes de couleurs en VB, que vous pouvez utiliser indifféremment.

• les couleurs définies par VB. Bous en trouverez la liste dans l’aide. Cela donnera des trucs du genre : Form1.ForeColor = VbBlack. Il y en a huit, plus la possibilité d’accéder directement aux couleurs de Windows (ça peut être pratique).
• Les couleurs de la palette. Il y en a 16, auxquelles on accède par la fonctionQBColor(i)
• La fonction RBG. C’est de loin la plus puissante, car elle permet de définir une couleur par mélange de Rouge, Bleu, Vert, chacune de ces trois couleurs étant dosée de 0 à 255.

Les coordonnées

Dès que l’on va placer ou déplacer des objets graphiques, il va falloir spécifier les coordonnées. Et ce n’est pas toujours d’une simplicité biblique.

Premier point, sur lequel M. de Lapalisse, un ancien voisin à moi, ne m’aurait pas démenti : l’écran a deux dimensions. Cette forte pensée étant posée, il reste que l’origine (le point 0, 0) se trouve en haut à gauche, et pas du tout en bas à gauche, là où tout occidental, hormis Bill Gates, l’aurait placé.

Deuxième problème : comment savoir quelles sont les dimensions de l’objet sur lequel vous voulez dessiner ? La réponse vous est donnée par les propriétés ScaleHeight etScaleWidth de l’objet.

L’astuce, c’est que l’on dispose de plusieurs unités de mesures possibles.

L’unité par défaut est le twip. Un twip, c’est très exactement 1/567^e de centimètre. Le gros avantage de cette unité, c’est qu’elle est indépendante du périphérique utilisé. Un centimètre, c’est toujours un centimètre (nous négligerons ci les effets de la relativité, la vitesse moyenne de déplacement des écrans par rapport à celui qui les regarde étant généralement négligeable par rapport à la vitesse de la lumière).

Mais il y a aussi le pixel. L’avantage du pixel, c’est sa rapidité. Vous épargnez à Windows une conversion, puisque un pixel, c’est un point. Mais l’inconvénient, c’est que selon les résolutions d’écran, le nombre de pixels varie fortement… (le nombre de twips varie aussi selon la taille de l’écran, me direz-vous, alors perdu pour perdu…)

On modifie (ce qui n’est généralement pas indispensable) le système de mesures par la propriété ScaleMode.

Contrôles graphiques

1 contrôles image

Ce sont des contrôles de VB, exactement comme les zones de textes, les boutons, etc., mais qui ont pour but de contenir des jolis dessins. Enfin, des dessins. Il y en a deux : le contrôle PictureBox et le contrôle Image. Voici un bref récapitulatif de leurs caractéristiques respectives :

	PictureBox	Image
Redimensionnement du contrôle	Contenu non modifié	Contenu déformé (si Propriété Strech = True)
Taille mémoire	Lourd	Léger
Traçage de graphiques durant l’exécution	Possible	Impossible

De ces trois critères, sauf cas très spécial, seul le deuxième est réellement important. Conclusion, hormis exception, il faut choisir un Image pour poser des images.

2 contrôles graphiques

Il y a aussi le contrôle Shape. C’est un contrôle qui peut prendre des formes géométriques simples : lignes, rectangles, cercles, ellipses. Quant au contrôle Line, il se contente de tracer des lignes. Ces deux derniers contrôles peuvent éventuellement servir à faire des schémas, mais si on veut des vrais graphiques, on n’a pas trop intérêt à s’y attarder, d’autant plus que ces contrôles ne gèrent pas les événements souris.

3 méthodes graphiques

Il existe un certain nombre d’actions dites " méthodes graphiques ", qui ne sont pas des contrôles, mais qui sont du code qui a pour rôle de tracer des dessins sur un objet (une Form, notamment). Le dessin s’effectue donc au cours de l’exécution du programme. Donc, cela gagne de l’occupation mémoire par rapport à un contrôle similaire. Ce n’est pas que je croie que cela serve beaucoup, mais pour mémoire, on a :

Pset permet de tracer des pixels un par un :

Form1.Pset(x,y),couleur

Line permet de tracer des lignes :

Form1.Line(xdep,ydep)–(xarr,yarr),couleur
Form1.Line –(xarr,yarr),couleur trace à partir du dernier point d’arrivée
Form1.Line (xdep,ydep)–step(x,y) les secondes coordonnées sont ici relatives

Circle dessine cercles et ellipses :

Form1.Circle(x,y),r où x et y sont les coordonnées du centre et r le rayon

On peut également dessiner des arcs de cercle, en utilisant la syntaxe complète :

Form1.Circle(x,y),r,c,ad,ar,e

Où c est la couleur, ad et ar les angles de départ et d’arrivée… en radians. Quant à e, c’est un paramètre qui permet de tracer des ellipses : il exprime le rapport de la largeur sur la hauteur du cercle.

Utiliser des fichiers image

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

• Soit on inclut directement les fichiers image dans l’application. Cela donnera lieu à la sauvegarde de fichiers .frx. Avantage, les graphiques font dorénavant partie de l’exécutable, et on est certain qu’ils seront présents quand on en aura besoin. Inconvénient, cela alourdit l’exécutable.
• Soit on utilise l’instruction LoadPicture dans le code. L’exécutable ira alors chercher le fichier désigné par cette ligne de code. Dans ce cas, le seul problème est d’être bien certain d’avoir installé les fichiers image avec votre exécutable, et dans le bon répertoire… Mais normalement, l’assistant d’installation prévoit ce cas et le gère tout seul, comme un grand.

·         Cours Visual Basic N°7
DLL, API… SOS

Gare à la casse et sus à la migraine ! Dans cette rapide présentation, on va voir quelques (je dis bien quelques) éléments permettant d’aller plus loin avec VB. En fait, on va voir comment VB peut (mais ce n’est pas obligé) utiliser des éléments de Windows pour améliorer ses (vos) performances. Mais là, inutile de préciser qu’entrant de plain-pied dans le domaine ésotérique de l’architecture de Windows, on n’est pas au bout de nos peines.

Un exemple : les boîtes de dialogue communes

Vous avez déjà remarqué que dans Windows, certaines boîtes de dialogue ont une tête standard : Fichier – Ouvrir, Fichier – Imprimer, et quelques autres. C’est que ces boîtes sont en quelques sorte préprogrammées, et que n’importe quel programmeur (dont vous-mêmes, public adoré), au lieu de se fader de les reproduire avec plus ou moins de bonheur, peut se contenter d’y faire appel.

Le principe de fond, sur lequel je reviendrai dans instant, est qu’un contrôle particulier est mis à votre disposition, du joli nom de Comdlg32.ocx. Ce contrôle permet d’utiliser la DLL correspondante (comdlg32.dll), c’est-à-dire du code déjà écrit. Au passage, notons qu’il existe des moyens d’utiliser des DLL même lorsqu’on ne vous donne pas le contrôle adéquat. Mais là, c’est une autre paire de manivelles qu’on abordera très, mais alors très bientôt.

Pour en revenir aux boîtes de dialogue dites " communes ", il faut commencer par charger le contrôle comdlg32.ocx, car ce contrôle, par défaut, ne vous est pas proposé. Il faut passer par Projet – Composants, et le choisir dans la liste.

Ensuite, l’astuce, c’est qu’avec ce seul contrôle, on peut ouvrir 6 boîtes de dialogues différentes. Il suffit d’appliquer à ce contrôle la méthode appropriée :

Boîte de dialogue voulue	Méthode à utiliser
Fichier Ouvrir	ShowOpen
Fichier Enregistrer	ShowSave
Couleur	ShowColor
Police	ShowFont
Imprimer	ShowPrinter
Aide	ShowHelp

Avant de lancer cette méthode pour ouvrir la boîte de dialogue, il faut ajuster les propriétés du contrôle, afin de préciser éventuellement des filtres (pour Fichier Ouvrir), un Titre pour votre boîte, etc. De même, la réponse de l’utilisateur sera stockée, comme d’habitude, dans certaines propriétés du contrôle. On a ainsi :

FileName : récupère le nom complet (avec chemin) du fichier sélectionné par l’utilisateur
FileTitle : récupère le nom du fichier sélectionné par l’utilisateur sans le chemin
Filter : définit le(s) type(s) de fichiers proposés par votre boîte de dialogue
FilterIndex : Définit lequel des filtres doit être utilisé
InitDir : Fixe le répertoire initial
DialogTitle : Titre de la boîte de dialogue
CancelError : Si True, le bouton Annuler provoquera une erreur.

Ces propriétés s’appliquent pour la boîte de dialogue Ouvrir. Pour les propriétés des autres boîtes de dialogue communes, cf. les bouquins ou l’Aide.

Voilà, c’était l’exemple le plus courant d’utilisation d’une DLL. Passons maintenant au cas général. Youpi.

Les DLL

Vous savez sans doute (ne serait-ce que pour avoir vu la tête d’Hervé quand vous en avez supprimé par mégarde) que les DLL jouent un rôle capital dans Windows. Mais que se cache-t-il derrière cet acronyme byzantin ? Eh bien, ce sont des " bibliothèques de liens dynamiques ", autrement dit des Dynamic Link Libraries. Ces DLL contiennent du code compilé (donc illisible) exécutant telles ou telles fonctions dans Windows.

Par exemple, Comdlg32.dll est une DLL qui contient le code nécessaire à l’exécution de boîtes de dialogue communes (d’où son Titre) aux applications Windows qui veulent s’en servir : Fichier – Ouvrir, Fichier – Enregistrer, et quelques autres. Mais peut-être le saviez-vous déjà ?

Donc, lorsque Word ou Excel vous proposent ces boîtes de dialogue, il faut comprendre que les lignes de code correspondantes ne font pas à proprement partie de Word ou Excel. Ces lignes de code sont stockées (une seule fois, donc) dans cette DLL. Word et Excel, eux, se contentent d’appeler la DLL, autrement dit le code qu’elle contient..

Il en va de même pour toutes les DLL, qui sont donc des morceaux de programme utilisables par d’autres programmes. Cela signifie que lorsque vous écrivez du VB, vous n’êtes pas obligé de réinventer à chaque fois l’eau tiède, la poudre à maquiller et le fil à couper le roquefort. Si une DLL contient déjà le code qui fait ce que vous souhaitez, vous pouvez (c’est même recommandé) appeler cette DLL plutôt que réécrire – généralement, moins bien – le code en question en VB.

Avec VB, vous pouvez donc :

• utiliser du code déjà présent dans Windows via une DLL
• créer de surcroît vos propres DLL (mais, là, attention les yeux)

On se contentera du premier tiret (quoique le second ne soit pas si inabordable que cela).

Alors, au fait, pourquoi " lien dynamique " ? C’est une question d’architecture. Un langage qui fonctionne avec des liens statiques incorpore à l’exécutable absolument tous les éléments de code dont il a besoin (cf. ce qu’on a dit pour le chargement des fichiers dans un contrôle image). Avantage, l’exécutable est autonome, et portable tel quel sur n’importe quel machine. Inconvénient, l’exécutable en question a tendance a être gros. L’avantage des langages et des systèmes fonctionnant avec des liens dynamiques, c’est que le code souvent utilisé est en quelque sorte partagé entre tous les exécutables qui en ont besoin à un moment où à un autre.

Avantage : s’il y a plein d’exécutables, on finit par y gagner en place occupée sur l’ordinateur.

Inconvénient, l’exécutable généré par un tel langage ne fonctionnera que s’il trouve présentes sur la machine toutes les DLL dont il a besoin. C’est précisément un des aspects cruciaux dont s’occupe l’assistant d’installation.

En fait, avec cette histoire de DLL, on retrouve peu ou prou à un autre niveau la division entre " logiciel d’application " et " système d’exploitation " qui existe depuis si longtemps en informatique. Mais là, la zones d’influence du " système d’exploitation ", disons plutôt de Windows, dépasse largement la gestion du disque dur et de l’écran. Les DLL contiennent du code gérant (liste non exhaustive) : l’interface graphique, les capacités multimédia…

L’API Windows

Aïe, Aïe, Aïe, que se cache-t-il derrière cette jolie pomme rouge ? Comme vous vous en doutez, ze worm is in ze frout.

API signifie : Application Programming Interface. C’est en fait un habillage de toutes les fonctions disponibles au sein des DLL. Donc, neuf fois sur dix, en VB, plutôt qu’attaquer directement les DLL (bon courage !) vous attaquerez l’API qui se chargera, elle, d’en dire deux mots aux DLL concernées. Cela dit, bon courage quand même.

En fait, l’API, tels Monsieur Jourdain et sa prose, vous vous en êtes servis tout ce semestre sans le savoir. Les jolis contrôles graphiques que vous avez utilisés (listes, boutons, etc.) sont des morceaux d’API, accessibles dans VB sous forme d’objets tout dessinés, avec leurs méthodes et leurs propriétés. Jusque là, donc, tout baigne. Le problème, c’est qu’il existe un certain nombre de fonctions de l’API qui ne sont pas a priori couvertes par des contrôles VB. C’est là, au moment où vous voudrez utiliser cette partie " cachée " de l’API, qu’on commence à rigoler pour de bon.

Première bonne blague : à part d’épais et indigestes bouquins (en plus, ils sont chers), il n’existe nulle part une liste des fonctions d’appel de l’API, vous disant quelle fonction fait quoi, et la syntaxe de l’appel. Résultat, il faut chercher, chercher, et chercher encore, crier au secours sur Internet, pour savoir quel appel API utiliser pour une tâche donnée, et en connaître la syntaxe. J’ai vu pas plus tard que l’an dernier un étudiant passer plusieurs heures à chercher comment, par un code VB, lancer Access avec une base de données précise chargée à l’ouverture… C’est pas sorcier, me direz-vous ? Pourtant, il n’a trouvé que juste avant de mourir d’épuisement.

Mais jetons un voile pudique sur les affres de la recherche, et imaginons que vous ayez enfin trouvé la syntaxe de l’appel API de vos rêves les plus fous. Comment le mettre en œuvre dans votre jolie application ?

En ce qui concerne la syntaxe, un appel API ne se distingue pas fondamentalement d’un appel à une procédure ou une fonction ordinaire, avec des paramètres.

Pour pouvoir utiliser de l’API (autrement dit une DLL), il faut tout d’abord déclarer la fonction en question, en indiquant les éléments suivants :

• le nom de la procédure ou fonction
• le fichier DLL où elle se trouve
• les paramètres qu’il doit recevoir
• le type de valeurs renvoyé, s’il s’agit d’une fonction

Tout cela, encore une fois, vous ne l’inventez pas. Il vous faut tous ces renseignements pour pouvoir travailler, renseignements recueillis dans un bouquin, sur le Net, ou auprès d’un ami si vous avez de mauvaises fréquentations.

Au total, la déclaration donnera un zorglub du genre :

Private Declare Function Duchemol Lib "Coucou32" Alias "Zigopaf" (Byval x As Long, Byval y As Long) As Long

• Declare indique qu'il s'agit d'une déclaration API
• Duchemol est le nom que vous choisissez pour votre fonction
• Lib indique qu'il va falloir aller piocher dans une DLL…
• …DLL dont le nom est "Coucou32"
• Alias est un paramètre éventuel, souvent omis par VB car le nom d'alias est le même que le nom de la DLL
• X et Y sont les paramètres envoyés à la fonction, avec leur type
• Le As Long final indique le type de valeur retournée par la fonction.
• Ouf.

Une fois cette fonction d’appel API déclarée, vous pourrez vous en servir comme de n’importe quelle fonction, avec par exemple en cours de programme :

Toto = Duchemol(45, 156)

Et voilà. C’était simple, non ?

L’assistant d’installation

Pour terminer ce chapitre sur une note plus gaie, je vous signale l’existence d’un assistant d’installation. Kesako ?

Eh bien, toute application VB, même une fois compilée, a besoin d’un certain nombre de fichiers pour pouvoir être exécutée sur une machine quelconque. En premier lieu, les fichiers DLL de VB5, que votre code VB compilé attaque à qui mieux mieux. Si ces DLL sont absentes de la machine d’arrivée, votre code tournera dans le vide (une minuscule fraction de seconde) et se plantera avec un long ululement d’agonie. Terrifiant spectacle.

Donc, plutôt qu’avoir à vous fader à la main de transférer les DLL concernées (quelles sont-elles, après tout ?) plus tous les autres fichiers dont votre exécutable risque d’avoir besoin (par exemple, des fichiers image ou des fichiers texte), vous avez ce petit outil.

Il va balayer votre application et noter soigneusement tous les fichiers dont elle aura besoin pour tourner, puis empaqueter tout cela dans un seul et même fichier auto-extractible.

Vous n’avez plus qu’à trimballer ce fichier final, et l’installation, sur n’importe quelle machine, y posera tout ce qui est nécessaire à votre application pour tourner.

Cours Visual Basic N°9
La gestion des sous-menus

Un petit point de vocabulaire pour commencer. Le terme menu désigne les choses comme Fichier, Edition, Affichage, etc. Les propositions figurant en dessous de ces menus sont appelées des commandes.

Il va de soi qu'avant de créer un système de menus, mieux vaut savoir ce qu'on va y mettre, comment les commandes seront organisées et à quelle procédure chaque commande sera liée. Une fois cette analyse faite, la réalisation technique n'est pas difficile.

Le fond de l'affaire

Les menus se créent via la fenêtre "Créateur de Menus" (ah ben ça alors, quelle surprise !) ouverte par l'icône du même nom.

Un menu est considéré par VB comme étant un objet, au même Titre qu'un bouton ou qu'une liste. Un menu possède donc une propriété caption et une propriété Name. Il est recommandé que le Name commence par Mnu (MnuFichier, MnuFenêtre, etc.). De la même manière, le nom des commandes inclues dans un menu comprendra le nom du menu (ex : CmdFichierOuvrir, CmdOutilsOrthographe, etc.)

La fenêtre "Créateur de menus" vous donne toute latitude d'éditer vos menus et commandes, autrement dit d'en ajouter, d'en supprimer, etc. Dans la liste des menus et des commandes, la hiérarchie entre menus, commandes et sous-commandes est indiquée par le décalage vers la droite, décalage réglé par les flèches horizontales.

Esthétique et Peaufinage :

• Lettres soulignées : dans la caption, un & précédant une lettre permet de souligner celle-ci, et de créer ainsi un accès clavier par la touche Alt (ex : &Fichier donneraFichier). Ceci est également valable pour les commandes.
• Barres de séparation : une commande ayant comme caption un simple tiret (celui sous le 6 du clavier) apparaîtra comme une barre de séparation entre deux commandes. Notez bien qu'une telle barre est considérée par VB comme une commande à part entière, et doit donc avoir un Name. C'est absurde, mais c'est ainsi.
• Raccourci clavier : on peut définir des raccourcis clavier (CTRL + quelque chose) qui apparaîtront dans le menu lui-même, comme c'est le cas pour les classiques "couper", "coller" et "copier". Il suffit de remplir la case correspondante dans le Créateur de menus (ceci peut également se programmer via la propriété de l'objet commande concerné)*
• Ajout de coches devant les commandes : dans le cas de commandes fonctionnant comme des interrupteurs. Il faut régler la propriété checked de la commande, soit via le Créateur de menus, soit dans le programme.
• Griser une commande : de la même manière que pour n'importe quel objet, ceci s'opère par la propriété Enabled, dans le Créateur de menus ou dans le programme.
• Rendre des commandes invisibles : là aussi, comme pour n'importe quel objet, il s'agit de la propriété visible.

Sous-menus

On peut souhaiter qu'une commande (suivie dans ce cas du célèbre triangle noir orienté à droite) fasse apparaître un sous-menu (ou si vous préférez, des sous-commandes). On peut pousser le vice jusqu'à créer quatre niveaux de sous-menus…

Il suffit d'opérer dans le Créateur de menus un décalage, exactement comme pour les commandes par opposition aux menus, mais de deux, voire trois, quatre ou cinq (pas plus).

Menus dynamiques

On entend par là des menus capables de se modifier automatiquement en fonction de l'utilisation du logiciel. Le grand classique du genre est le menu Fichier, dans lequel apparaissent les quatre derniers documents ouverts.

Le plus simple est alors de procéder de la manière suivante :

1.     créer les commandes "vides", c'est-à-dire sans leur attribuer de caption, dans le créateur de menus. Dans l'exemple ci-dessus, on prévoirait ainsi 4 commandes vides. Une solution simple est de donner un seul Name et de jouer sur les index, pour pouvoir faire ensuite une boucle.

2.     Il suffit ensuite d'écrire le code modifiant la caption de ces quatre commandes. Naturellement, cela implique également que vous ayez aussi écrit du code permettant à votre application de mémoriser les quatre derniers fichiers ouverts.

Menus contextuels

Je vous rappelle qu'il s'agit généralement de menus apparaissant à l'écran sur un clic droit de la souris, et dont le contenu est lié à la nature de l'objet pointé.

Un clic de souris est un événement dit MouseUp (MouseUp correspond au fait de relâcher le bouton, MouseDown au fait de l'appuyer).

Une procédure se déclenchant lorsqu'on clique du bouton droit sur un objet s'écrira :

Private Sub objet_MouseUp

If Button = 2 Then

PopupMenu mnuTruc

End If

End Sub

NB : On teste la variable Button pour savoir quel bouton a été cliqué ; le clic droit et le clic gauche représentent pour VB le même événement (MouseUp) avec une variable possédant deux valeurs différentes, et non deux événements distincts.

L'apparition d'un menu à l'endroit du pointeur de la souris se fait par la méthode PopupMenu. Naturellement, le menu proprement dit (ici MnuTruc) devra avoir été préalablement créé.

Il existe des raffinements sans nom pour faire afficher le menu ailleurs qu'à côté du pointeur, ou dans des positions bizarres… on n'entre pas là-dedans, vous regarderez l'Aide si vraiment vous tenez à vous lancer dans ce genre de choses.