L’interface graphique en
I.Environnement Visual Studio
Après avoir fait connaissance des concepts de la programmation objet, on va se familiariser avec l'interface VB, c'est-à-dire avec les principaux outils qu’offre l'environnement de développement Visual Studio.
Les habitués de Visual Studio 6.0 ne seront pas trompés : l’interface de Visual Basic .net reprend la plupart des palettes standards avec quelques outils en plus :
La barre d’outils regroupe les différents contrôles par catégories;
La zone centrale permet tour à tour d’écrire le code et de définir les interfaces graphiques utilisateurs;
A droite, l’explorateur de solutions et la fenêtre de propriétés;
La première chose à faire, c'est d'assimiler l'architecture des constructions qu’on va créer et le vocabulaire qui va avec. Et ça, ce n'est pas rien, tant à côté d'une application VB, et autant consacrer quelques minutes à se mettre les idées au clair plutôt que perdre ensuite des heures juste parce qu'on s'est mélangé les pinceaux dans les arborescences et les dénominations.
Alors, une application , c'est quoi ? C'est :
Un ensemble de fichiers formant ce qu'on appelle le code source, écrit dans le langage Visual Basic.
Un fichier exécutable, produit à partir de ce code source. Rappelle que le fait d'engendrer un fichier exécutable à partir du code source s'appelle la compilation.
En ce qui concerne le code source, VB va l'organiser de la manière suivante :
Le point de départ d'une application VB, c'est une solution. Lorsqu'on crée une nouvelle solution, VB demande pour celle-ci un nom et un répertoire. Il va alors faire trois choses :
i. Créer à l'emplacement indiqué le répertoire portant le nom de la solution;
ii. Dans ce répertoire, toujours avec le nom de la solution, créer un fichier *.sln contenant les informations de la solution.
iii. Et toujours dans ce répertoire, toujours avec le nom de la solution, créer un fichier caché *.suo, contenant les options choisies dans Visual Basic par le programmeur qui a développé la solution.
Mais ce n'est qu'un début. En effet, dans nos solutions Visual Basic, on va devoir insérer nos applications, c'està-dire nos projets. Si on le souhaite, une même solution peut contenir plusieurs, voire des dizaines de projets. Cela dit, on ne recommande pas cette stratégie. On considèrera donc, qu'une application VB = un projet = une solution.
En effet, chaque projet est lui aussi caractérisé par un nom et un répertoire de sauvegarde. Mais, et c'est là que c'est fort, ce répertoire n'est pas forcément un sous-répertoire de la solution qui contient le projet - même si lorsqu'on débute, ce soit très vigoureusement recommandé.
Il n'y a donc pas de rapport entre le fait que les objets "solution" contiennent les objets "projets", et le fait que le répertoire où est enregistrée la solution contienne les répertoires où sont enregistrés les projets Toujours est-il que VB va non seulement créer un répertoire au nom du projet, mais qu'il va mettre dans ce répertoire toute une série de fichiers, dont un fichier au nom du projet et à extension *.vbproj, fichier dans lequel est stockée toute la structure du projet.
Remarque:
Il faut faire très attention lorsqu'on incorpore un projet dans une solution : en effet, la commande Nouveauprojet entraîne obligatoirement la création d'une nouvelle solution. En revanche, pour insérer un projet dans une solution existante, il faut choisir Ajouter un projet.
Enfin: dans chaque projet, il y a un certain nombre d'éléments de base. Ces éléments sont, pour l'essentiel, des
Form, ou formulaires. Une application Windows basique compte un seul formulaire, et une application complexe peut en rassembler plusieurs dizaines. Chaque formulaire sera sauvegardé dans un fichier différent, dont l'extension sera *.VB. Il faut noter que c'est dans ces fichiers *.VB que se trouve le code proprement dit.
FARIH Saïd
Conseils:
On appliquera donc impérativement les règles suivantes :
Une solution par projet, un projet par solution;
Le projet devra être sauvegardé dans un sous-répertoire de la solution;
En ce qui concerne l'exécutable, A la différence de certains autres langages, ne produit pas un code directement exécutable par toutes les machines. Les instructions contenues dans un exécutable sont écrites dans un langage appelé MSIL, pour MicroSoft Intermediate Langage. Comme son nom l'indique, ce langage s'adresse à des couches "intermédiaires" de la machine, à savoir d'une part Windows lui-même, d'autre part à une couche logicielle appelée le Framework .NET (qu'on peut traduire par "infrastructure .NET").
Pour pouvoir exécuter un exécutable , une machine doit donc impérativement comporter ce , que l'on peut télécharger gratuitement sur le site de Microsoft.
Comment déclencher la compilation ? En passant par la commande Générer, qui propose le(s) nom(s) des projets de la solution encours. Le fichier .exe est alors généré dans le sous-répertoire bin correspondant au projet.
Le logiciel Visual Basic Studio est utilisé pour faciliter l'écriture de programmes en mettant à notre disposition, sous une forme facilement accessible, les classes Windows les plus communes (boutons, listes, cases, et tout ce qui s'essuie).
Lorsqu'on va la programmer via Visual Studio, une application va toujours pouvoir être abordée sous deux angles complémentaires :
L'aspect graphique, visuel (son interface). Dans la fenêtre principale de VB, on pourra mettre les différents objets qu’on veut voir figurer dans notre application, les poser sur notre formulaire, modifier leurs propriétés par
Le code proprement dit, où on va entrer les différentes procédures en rapport avec le formulaire en question :
Passons au code. Visual Studio va en fait décrypter notre code au fur et à mesure de sa rédaction, et on donner en temps réel des indications via des codes de couleur. Ainsi :
Les titres de procédures seront écrits en gris;
Les mots-clés du langage seront portés en bleu;
Les commentaires seront en vert;
Toute ligne comportant une faute de syntaxe, ou posant un problème au compilateur, sera immédiatement soulignée. Qui plus est, il suffira d'amener le curseur de la souris au-dessus de l'erreur pour que la raison en soit immédiatement affichée dans une bulle d'aide. On dispose donc d'un premier outil de débogage.
Lorsqu’on tape dans le code un nom d'objet, et pour peu que ce nom soit reconnu (c'est-à-dire qu'il existe bel et bien un objet de ce nom dans notre application), sitôt qu’on entre le point qui termine le nom de l'objet, apparaît une liste déroulante avec l'intégralité des propriétés et méthodes disponibles pour cet objet.
Comme on est dans un langage qui est un langage structuré, le code est organisé sous forme de blocs qui peuvent être déployés ou masqués, pour plus de lisibilité, via les petites icônes placés à gauche de la tête de chaque bloc.
Exemple
OptionStrictOn'Force la declaration des variables et le transtypageImportsSystem'Permet l'utilisation des outils de base du langage
ModuleMyFirstProgram
'Procedure principale. Point d'entree de l'execution du programme
SubMain()
CallConsole.WriteLine("Ce programme vous dit : ")
CallConsole.WriteLine("Hello world")
()
Bâtir une application VB, c'est généralement faire de fréquents allers-retours entre les deux représentations. Pour cela: il suffit de se servir des onglets disponibles sur le haut de chaque fenêtre. b.Les explorateurs
i. Explorateur de serveur
L’explorateur de serveur permet de recenser sous forme hiérarchique l’ensemble des objets d’un serveur (Serveurs SQL, journaux, Services …). Cette fenêtre est principalement utilisées afin d’accéder au schéma d’une base de données utilisée dans une application.
ii. La boîte à outils et les contrôles standards
| Contrôle | Nom du contrôle | Utilité |
| Label | Afficher un texte statique : un libellé | |
| TextBox | Afficher et rentrer une valeur au clavier | |
| Button | Lancer l’exécution une procédure événementielle | |
| ListBox | Afficher une liste statique de valeur | |
| ComboBox | Combiner l’utilité des contrôles TextBox et ListBox | |
| PictureBox | Afficher une image dans un cadre. Celui-ci peut être redimensionné en fonction de l’image (Autosize = True) | |
| RadioButton | Sélectionner une option. Si utilisé en plusieurs instances (Option Button), une seule peut être choisie | |
| CheckBox | Sélectionner une option. Si utilisé en plusieurs instances (Check Box), une ou plusieurs peuvent être choisies | |
| GroupBox | Créer une fenêtre au sein d’un formulaire et créer un groupe de contrôles. |
La partie graphique de l’application va contenir un (ou plusieurs) formulaire(s). Sur un formulaire, on peut placer un ou plusieurs objets graphiques ou ce qu’on appellera des contrôles (Bouton à cliquer, Champ libellé (texte statique), Champ texte à saisir au clavier, Menu, etc.).
Ces contrôles sont des objets pré-programmés dont l’utilité principale est de faciliter l’interaction avec l’utilisateur. Chacun de ces objets graphiques a une fonctionnalité bien précise. Le tableau suivant résume les contrôles standards de base les plus utilisés:
Les contrôles standards dans VB se trouvent dans la Boîte à outils (ToolBox). D’autres contrôles plus élaborés (Components) peuvent être ajoutés dans la boîte à outils, en sélectionnant dans la barre du menu :
Project/ Add Components.
iii. L’affichage de classes
L’affichage de classes liste de manière hiérarchique les différentes classes du projet ainsi que leurs méthodes, propriétés, évènements et autre relations d’héritage.
iv. Fenêtre de propriétés
Déjà présente dans la version 6.0, cette fenêtre recense toutes les propriétés relatives à l’objet sélectionné.
Chaque fois qu'un contrôle (ou plusieurs) est sélectionné, la fenêtre des propriétés (située en standard à droite de l'écran) affiche les valeurs associées à ce contrôle. C'est-à-dire que se mettent à jour la liste des propriétés (qui comme on l'a vu varie d'une classe, donc d'un contrôle, à l'autre) et la valeur de ces propriétés (qui varie d'un contrôle à l'autre, même lorsqu'ils sont de la même classe).
Les propriétés qui sont affichées là sont les propriétés par défaut du contrôle. Ce sont celles qu'aura le contrôle au moment du lancement de l'application. Bien sûr, par la suite, il n'est pas exclu que ces propriétés soient modifiées, notamment par des lignes de code. Mais, pour fixer les propriétés voulues pour chaque contrôle au lancement de l'application, le plus simple est de fixer à la main, sans code, les valeurs désirées dans cette fenêtre des propriétés.
On peut citer quelques propriétés de ‘Form1’ et leurs valeurs respectives:
Name = Form1, nom logique utilisé pour référencer l’objet dans du code VB.
BackColor = &H800000, couleur de fond de l’objet Form1.
Text = Form1, nom qui apparaît visuellement sur l’objet, celui-ci peut être différent de la propriété Name. v.Explorateur de Solutions
L’explorateur de solutions (Ex explorateur de projet sous VB 6.0) référence l’ensemble des éléments des projets (Fichier de configuration pour l’assemblage, super classes hérités, Feuilles….)
Une solution contient les fichiers suivants :
.sln : fichier de configuration de la solution
.vbproj : fichier projet, (ancien .vbp)
.VB : fichiers contenant du code (anciens .bas, .frm, .cls)
.resx : associé à une feuille, contient les ressources
Renommer le fichier programme : ce doit être le nom du module
Dans Solution Explorer : Bouton droit sur le nom du programme () ? Rename vi.L’aide dynamique
L’aide dynamique propose à tous les moments de la conception des rubriques d’aide utiles en fonction de ce qu’on faîtes. Par exemple, la rubrique « créer une collection de contrôles » sera affichée lorsqu’on ajoutera un bouton radio à l'application. Appuyer sur F1 pour accéder à l'aide en ligne.
liste des tâches
La fenêtre liste des tâche permet de recenser l’ensemble des tâche à réaliser sur le projet. Cette liste peut être remplie de plusieurs façons :
Une tâche qu’on aura nous même définie (ex : appeler le client à 11h);
Une tâche issue des commentaires du code : tous commentaires du code commençant par « todo: » sera automatiquement ajouté;
Le Framework Visual Basic .Net permet la création de formulaires Windows afin d’établir des interfaces graphiques entre l’utilisateur et le code. Ces formulaires sont des fenêtres qui contiendront des contrôles (Champs texte, boutons, liste déroulantes ….).
Les formulaires sont les éléments de base des applications graphiques existe 2 solutions pour la création de formulaires sous le Framework .Net :
i.Windows Forms
Ce sont les formulaires dont disposait Visual basic 6. Les applications basées sur ces formulaires sont utilisés pour le développement d’applications pour lesquelles la plupart des traitements se font sur la machine cliente et qui ont besoin d’accéder aux ressources de la machine (fichiers, lecteurs, imprimantes …). Forms
Les applications à base de Web Forms sont destinées à être utilisées sur le Web par le biais d’un navigateur. Ce genre d’application présente plusieurs avantages comme un déploiement facile dans le sens où seuls les composants du navigateur doivent être installés, une maintenance simplifiée car le programme est stocké sur le serveur et, enfin, les applications développées sont indépendantes de toutes plateformes dans le sens où elles n’utilisent que les ressources du navigateur.
En fonction de l’application à réaliser, plusieurs modes de présentation des feuilles peuvent être utilisés :
Mono document : Ce genre d’application appelée SDI (Single Document Interface) ne permet l’affichage que d’une fenêtre à la fois. L’outil Paint en est un bon exemple.
Multi document : Les applications MDI (Multiple Document Interface) sont constituées d’une fenêtre principale (Fenêtre mère) contenant à son tour plusieurs documents (fenêtre fille). Microsoft Word est une application MDI.
Explorateur : C’est le mode de présentation le plus utilisé. Il permet un affichage hiérarchique des menus sur la partie gauche et l’affichage des éléments sous forme de liste sur la partie droite. L’outil « Gestion de l’ordinateur » sous Windows 2000 en est un exemple.
II.Manipulation des contrôles
Un contrôle est un objet créé à partir de certaines des classes définies dans Windows. En standard, VB propose plusieurs rubriques au sein de sa boîte à outils, et rien que dans la principale d'entre elles, la rubrique Windows Forms, une quarantaine de contrôles,
Créer des contrôles à partir des classes proposées en standard est extrêmement simple. Il suffit d'aller piocher d'un clic de souris le contrôle voulu dans la boîte à outils (qui, dans la configuration normale, se trouve à gauche de l'écran) et d'effectuer un glisser-déplacer sur le formulaire pour donner à ce contrôle la taille et l'emplacement voulus. A signaler, qu'un simple double-clic dans la boîte à outils constitue une solution alternative. Par la suite, on peut toujours modifier l'emplacement et la taille d'un contrôle, d'un simple coup de souris bien placé.
Pour supprimer un contrôle, c'est encore plus simple : on le sélectionne, et ensuite la touche SUPPR l'enlèvera. Si l'on veut manipuler plusieurs contrôles du formulaire à la fois, on peut sélectionner toute une zone (par un habile cliquer-glisser), ou encore sélectionner individuellement chaque contrôle en maintenant la touche CTRL enfoncée.
Les contrôles permettent de créer l’interface entre l’utilisateur et notre application. C’est via les contrôles que l’utilisateur pourra saisir des données, effectuer des sélections et déclencher des actions par l’intermédiaire des événements.
De manière générale, les contrôles sont des objets graphiques, c’est à dire qu’ils seront placés et visibles sur le formulaire. Cependant, certains contrôles offrant des fonctionnalités de programmation n’apparaîtront pas sur le formulaire mais dans une zone située en bas et uniquement en mode « Design ».
Les contrôles Visual Basic .Net sont des classes issues de la classe de base « control ». Cette dernière assure les fonctions élémentaires comme le placement sur une feuille, leur position … A cette classe est ajoutée une classe dérivée permettant la personnalisation des différents contrôles.
i.Propriétés
Name: Nom du contrôle. Ce nom ne comporter que des lettres et le caractère underscore « _ ».
Anchor: Les ancres permettent de modifier automatiquement la taille d’un contrôle lors du redimensionnement d’un formulaire. Chaque contrôle possède sa propre ancre.
Lors du paramétrage, on doit définir sur quels bords du conteneur est ancré le contrôle. Dans l’exemple suivant, on crée un contrôle ancré à gauche et à droite :
CanFocus: Booléen spécifiant si le contrôle peut recevoir le focus.
CanSelect: Booléen spécifiant si le contrôle peut être sélectionné.
Dock: Dans le même esprit, la propriété « Dock » permet d’ancrer un contrôle aux à un bord du conteneur. Dans l’exemple suivant, le bouton est ancré en bas :
Enabled: Cette propriété est une valeur booléenne spécifiant si le contrôle est accessible ou non. Dans le second cas, le contrôle apparaîtra grisé.
Location: La propriété Location est un objet permettant de définir l’emplacement du contrôle par rapport à son conteneur. Il est composé de deux propriétés (X et Y) qui définissent ses coordonnées par rapport au coin supérieur gauche du conteneur.
Locked: Contrairement à la version précédente, cette propriété ne bloque pas le contrôle lors de l’exécution mais lors de la conception. Il permet d’éviter de modifier les propriétés d’un contrôle.
Modifiers: Cette propriété paramètre la visibilité au niveau programmation de l’objet. Elle peut prendre les valeurs suivantes :
| Valeur | Description |
| Public | Accessible à partir de tous les éléments de la solution |
| Protected | Accessible à partir des membres de la classe et des sous classes |
| Protected Friend | Correspond à l’union des visibilités Friend et Protected |
| Friend | Accessible à partir du programme et des assemblages liés |
| Private | Accessible à partir des membres de la classe |
Par défaut, la visibilité est friend.
Size: Cet objet permet de définir la taille du contrôle. Il est composé de deux propriétés, width (largeur) et height (hauteur).
TabIndex: Indice définissant l’ordre de tabulation du contrôle par rapport à son conteneur.
Text: Cette propriété référence le texte contenu ou affiché dans un contrôle (Par exemple, le texte affiché sur un bouton).
Visible: Cette propriété détermine si le contrôle est visible lors de l’exécution. Attention, aucun changement n’est visible lors de la conception.
ii. Méthodes
| Méthode | Description |
| Focus | Donne le focus au contrôle |
iii. Evénements
| Evénements | Description |
| Click | Activé lors du clic sur le contrôle |
| DoubleClick | Activé lors du double clic sur le contrôle |
| Enter | Activé lorsque l’utilisateur entre sur le contrôle |
| GotFocus | Activé lorsque le contrôle reçoit le focus |
| KeyDown | Touche enfoncée |
| KeyPress | Touche enfoncée et relâchée |
| KeyUp | Touche relâchée |
| LostFocus | Activé lorsque le contrôle perd le focus |
| MouseDown | Bouton souris enfoncé |
| MouseUp | Bouton souris relâché |
| MouseMove | Souris déplacée sur le contrôle |
| MouseWheel | Déplacement de la roulette |
| Resize | Déclenché lorsque le contrôle est redimensionné |
Premiers contrôles
Ouvrir donc la boîte à outils, et regardons ça de près. Que trouve-t-on ?
La classe Form (qu'on appelle également le formulaire), issue de la classe , est l'élément de base, obligé et fondamental, de toute application VB pour Windows. C'est sur une Form, et uniquement sur une Form, qu’on pourra éventuellement poser d'autres contrôles. Et même si on peut à la rigueur la rendre invisible, de toute façon, elle est quand même là. C'est également dans la Form que seront rassemblées toutes les procédures événementielles liées aux contrôles qu’on aura créés sur cette Form.
On peut d'entrée noter plusieurs propriétés de la classe (donc de tous les objets Form créés à partir de cette classe), propriétés qu’on retrouvera dans la totalité des autres contrôles proposés par VB :
Name : il s'agit du nom de l'objet, exactement comme une variable porte un nom de variable. La valeur de cette propriété n'est donc pas visible à l'écran : il s'agit d'un nom qui sert uniquement dans le code, pour désigner l'objet en question.
Text : une autre propriété quasi-universelle des contrôles est le texte qui leur est associé à l'écran. Pour une Form, il s'agira du texte qui figure en haut, dans la barre de titre. Pour un bouton, ce sera le texte écrit dessus, pour une case, le texte qui figure juste à côté, etc. À l'inverse de la propriété Name, Text ne joue aucun rôle du point de vue du code, et un rôle essentiel du point de vue de l'interface.
Size : Il s'agit évidemment de la taille, autre propriété partagée par la presque totalité des contrôles. Il faut remarquer que la propriété Size est d'un type particulier, le type Size, qui est un type structuré composé de deux Integer.
Pour modifier sa valeur par du code: il faut utiliser une variable de type Size déjà existante, ou, le plus souvent, la créer à la volée par le constructeur New. Pour fixer par exemple la taille de la Form à 500 pixels sur 300, et sachant que la manière la plus simple de désigner la Form dans une des procédures qui lui sont liées est d'employer le mot Me, on pourra écrire :
Me.Size =NewSize(500, 300)
Sachant qu'il y a moyen de contourner l'obstacle, puisque plutôt d'utiliser ce type Size structuré, on peut découvrir qu’on a directement accès à deux autres propriétés, Height et Width, beaucoup plus maniables car de type Integer. Ainsi, la ligne ci-dessus pourra avantageusement être remplacée par :
Me.Width = 500
Me.Height = 300
Visible : cette petite propriété booléenne rend des services inestimables, puisqu'elle permet de masquer (quand elle vaut False) n'importe quel contrôle.
D'autres propriétés de la classe Form sont propres à cette classe, et ne se retrouvent pas - ou rarement - dans d'autres classes.
Il s'agit par exemple de :
Startposition : qui détermine la position de la fenêtre sur l'écran lors du lancement de l'application;
BackgroundImage : qui permet de désigner une image d'arrière-plan pour une Form;
FormBorderStyle : qui détermine le type de bordures utilisé;
Exemple
PrivateSubButton1_Click(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesButton1.Click
Me.Size =NewSize(500, 300)
clic = clic + 1
Me.Text ="Nombre de clics : "& clic EndSub
Côté événements, les Form sont capables d'en recevoir - autrement dit, d'en gérer - un certain nombre. Parmi ceux-ci, les plus importants, pour commencer, sont sans doute Load et Activate.
Définitions
L'événement Activate correspond au fait que la Form spécifiée devient la fenêtre active. L'événement Load correspond au chargement de la fenêtre en mémoire vive.
Dans le cas d'une application qui ne compte qu'une seule Form, les deux événements se confondent. En effet, l'unique Form se charge au lancement de l'application, devenant par la même occasion la Form active, et le restant sans discontinuer jusqu'à la fin de cette application.
Mais dès qu'une application compte plusieurs Form, les choses se passent tout autrement. Toutes les Form vont en effet être chargées au lancement de l'application (déclenchant ainsi les événements Load). Mais une seule sera active. Par la suite, chaque fois que l'utilisateur passera d'une Form à l'autre, il redéclenchera l'événement
Activate pour la Form sur laquelle il vient d'atterrir.
Les événements Activate et Load se prêtent particulièrement bien à des instructions d'initialisation : c'est là, avant que l'utilisateur ait eu le temps de faire quoi que ce soit, qu'on remet les compteurs à zéro, qu'on remet les cases et les zones de saisie à blanc (ou qu'on y réécrit les valeurs par défaut), etc. b.propriétés particulières
AcceptButton
Lorsque l’utilisateur appuie sur la touche entrée, la méthode liée à l’événement « click » du bouton d’acceptation sera automatiquement déclenché. Généralement, c’est le bouton « ok » ou « sauvegardé » qui est paramétré comme AcceptButton.
AllowDrop: Spécifie si le formulaire gère le Drag and Drop (Glisser déposé).
AutoScale: Si cette option est activée, la taille des contrôles et du formulaire sont automatiquement redimensionnés lors d’un changement dynamique de la police d’écran.
AutoScroll: C’est une nouveauté de la version .Net : elle permet de placer automatiquement des barres de défilement lorsque la taille du formulaire ne permet pas l’affichage de tous les contrôles qu’il contient.
BackColor: La propriété backColor définit la couleur de fond du formulaire.
BackgroundImage: Il est possible de définir une image comme fond pour le formulaire. L’image sera automatiquement répétée en mosaïque.
CancelButton: Le bouton d’annulation réalise l’opération inverse du bouton d’acceptation. Il permet déclencher l’événement « click » d’un bouton du formulaire lorsque l’utilisateur appuie sur touche escape.
ControlBox: La propriété ControlBox définit si le menu système apparaît au niveau de la barre de titre du formulaire :
Le menu système peut également être modifié avec les propriétés « MinimizeBox », « MaximizeBox » et « HelpButton ».
FARIH Saïd
| Propriété | Description | Exemple |
| Name | Nom de la police utilisée | Garamond |
| Size | Taille de la police | 12.5 |
| Unit | Unité de mesure pour la police (Sachez que la plupart des logiciels utilisent l’unité « point ») | Point |
| Bold | Texte en gras | True |
| GdiXXXX | Paramètres sur le jeu de caractère utilisé | |
| Italic | Texte en italique | True |
| Strikeout | Texte barré | False |
| Underline | Texte souligné | True |
ForeColor: Couleur d’affichage par défaut pour les textes et graphismes du formulaire.
FormBorderStyle: Style de bordure du formulaire :
| Valeur | Apparence | Dimensionnable | Valeur | Apparence | Dimensionnable |
| None | Non | FixedSingle | Non | ||
| FixedDialog | Non | Sizable | Oui | ||
| Fixed3d | Non | SizableToolWindow | Oui | ||
| FixeToolWindow | Non |
HelpButton: Affiche le bouton d’aide à gauche de la barre de titre. Attention, le bouton ne sera pas affiché si les boutons min et max sont activés.
FARIH Saïd
Pour déclencher un bloc d’instruction lorsque l’utilisateur demande l’aide (Soit à partir de la touche F1, soit à partir du bouton d’aide, on doit créer une méthode implémentant l’événement :
PrivateSubnom_méthode(ByValsenderAsObject,ByValhlpeventAsSystem.Windows.Forms.HelpEventArgs)Handlesobjet.HelpRequested
Le code suivant permet d’afficher une boite de dialogue lorsque l’utilisateur demande l’aide sur le champ texte « text1 » qui doit être déclaré avec le mot clé « WithEvents ». La procédure suivante implémente l’événement :
PrivateSubtextBox_HelpRequested(ByValsenderAsObject,ByValhlpeventAs
System.Windows.Forms.HelpEventArgs)HandlesTextBox1.HelpRequested
'converti le paramètre passé en control
DimrequestingControlAsControl =CType(sender, Control)
MsgBox(CStr()) 'valide la gestion de l’événement hlpevent.Handled =True
L’objet « sender » passé en paramètre référence l’objet à l’origine de la demande d’aide.
Icon: Définit l’icône liée au formulaire : cette dernière apparaît dans la barre de titre.
IsMDIContainer: Détermine si le formulaire est un conteneur MDI, c’est à dire s’il est capable de contenir d’autres fenêtres.
Dans le cas d’un formulaire MDI, on doit spécifier le code afin d’afficher d’autres formulaires à l’intérieur. Le code suivant permet l’affichage d’un formulaire fils : dans cet exemple, Form2 est le formulaire MDI, Form1 et Form3 sont les formulaires enfant. Il faut également paramétrer l’option « IsMdiContainer » du Form2 à True.
PrivateSubForm2_Load(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)
HandlesMyBase.LoadDimf1AsNewForm1 Dimf2AsNewForm3 f1.MdiParent =Me () f2.MdiParent =Me ()
Location: Cette objet défini la position du formulaire par rapport à son conteneur (c’est à dire l’écran ou le formulaire parent dans le cas d’application MDI). Deux propriétés permettent de définir la position :
X : distance entre le bord gauche du conteneur et le bord gauche du formulaire
Y : distance entre le haut du conteneur et le haut du formulaire
Locked: Détermine si le formulaire est verrouillé ou non : cette propriété est identique à « enabled » mais elle ne grise pas l’apparence du formulaire.
MinimizeBox, MaximizeBox: Détermine si les boutons « Agrandir » et « Réduire » sont visibles. Leur affichage empêchera l’affichage du bouton d’aide.
MinimumSize, MaximumSize: Cet objet définit la taille minimale et maximale que peut avoir le formulaire. Cet objet est généralement utilisé pour éviter que l’utilisateur réduise la fenêtre au point de ne plus avoir accès aux contrôles. Pour chaque objet, deux propriétés sont disponibles : width (largeur) et height (hauteur).
Opacity: Définit un pourcentage d’opacité pour la fenêtre. Une valeur de 100% rend la fenêtre opaque.
(Exemple avec50%)
ShowInTaskBar: Détermine si un nouveau bouton est ajouté dans la barre des tâches lorsque la fenêtre est ouverte :
Size: Cet objet définit la taille du formulaire à l’aide de deux propriétés : width (largeur) et height (hauteur).
Startposition: Définit la position de départ lorsque la fenêtre est ouverte :
| Valeur | Description |
| Manual |
Position définie par la propriété location |
| CenterScreen | Centré par rapport à l’écran |
| WindowsDefaultlocation | Situé à l’emplacement par défaut de Windows et possède la taille définie dans size |
| WindowsDefaultBounds | Situé à l’emplacement par défaut de Windows et possède la taille par défaut de Windows |
| Centerparent | Centré par rapport à la fenêtre ayant déclenché l’ouverture. |
Text: Détermine le texte affiché dans la barre de titre
FARIH Saïd
TopMost: Si cette option est activée (true) le formulaire sera toujours au dessus de tous les autres formulaires, même s’il n’est pas activé. Cette option se prête particulièrement bien pour les boîtes à outils qui doivent toujours rester accessibles.
TransparencyKey: Du meilleur effet, cette propriété définit la couleur de transparence du formulaire : si on spécifie la couleur jaune en tant que TransparencyKey, toutes les zones du formulaire jaune seront transparentes :
WindowState: Détermine l’état du formulaire lors de l’ouverture :
| Valeur | Description |
| Normal | Le formulaire apparaît avec sa taille standard |
| Minimize | Le formulaire est réduit lors de l’ouverture |
| Maximize | Le formulaire est en plein écran lors de l’ouverture |
ShowDialog: Affiche le formulaire en tant que feuille modale, c’est à dire qu’au niveau de l’application, la fenêtre restera au premier plan tant qu’elle n’est pas fermée.
Les événements correspondent au cycle de vie de l’objet formulaire. Ils sont listés dans l’ordre chronologique.
New: L’objet formulaire est en cours de création
Load: Le formulaire ainsi que ses composants sont chargés mais il n’est pas visible.
Paint: Se produit lorsque le formulaire est redessiné. Cet événement peut apparaître plusieurs fois : par exemple au démarrage et lorsque le formulaire réapparait devant un autre.
Activated: Le formulaire récupère le focus.
Deactivate: Le formulaire perd le focus
Closing: Le formulaire est en cours de fermeture, les différents éléments le composant sont détruits. Le formulaire est cependant encore visible.
Closed: Le formulaire est fermé et maintenant invisible.
Dispose: L’objet formulaire est détruit.
Resize: Cet événement survient lorsque le formulaire est redimensionné. Généralement utilisé pour modifier la taille des contrôles le composant.
Click: L’utilisateur clique sur le fond du formulaire
DoubleClick: L’utilisateur double clique sur le fond du formulaire
On va à présent découvrir deux nouvelles fonctions, qui n'ont aucun équivalent dans les langages traditionnels (procéduraux), car elles sont directement liées au fait que VB soit un langage basé sur l'interface Windows. a.Les boîtes de dialogue
Les boîtes de dialogue intégrées sont des feuilles modales (c’est à dire qu’elles suspendent l’exécution du programme jusqu’à leur fermeture) destinées à afficher une information ou demander une saisie. i.Boite de message
La boîte de message (MsgBox) permet l’affichage d’une information et donne la possibilité de configurer les boutons, le titre et l’icône associée.
(prompt, titre, type_boutons, icône, bouton_par_defaut)
FARIH Saïd
| Types de bouton | Constantes de Retour La définition du type de boutons modifie l’affichage mais permet à la méthode .Show de retourner une valeur correspondant au bouton sélectionner par l’utilisateur. | ||||||||||||||||
| |||||||||||||||||
| Constantes de retour (membres de la classe DialogResult) | |||||||||||||||||
| Constante | Description | ||||||||||||||||
| Ok | Bouton Ok | ||||||||||||||||
| Cancel | Bouton Annuler | ||||||||||||||||
| Abort | Bouton Abandonner | ||||||||||||||||
| Retry | Bouton Réessayer | ||||||||||||||||
| Ignore | Bouton Ignorer | ||||||||||||||||
| Yes | Bouton Oui | ||||||||||||||||
| No | Bouton Non | ||||||||||||||||
Le rôle de cet argument est double : il doit indiquer d'une part quel est le jeu de boutons souhaité, parmi les six disponibles ("Abandonner, Réessayer, Ignorer", "OK", "OK, Annuler", "Réessayer, Annuler", "Oui, Non", "Oui, Non, Annuler"). Il doit également stipuler quelle illustration viendra éventuellement égayer votre boîte à messages, parmi les quatre possibles (Critical, Exclamation, Information, Question).
En fait, l'argument attendu est de type Integer. Et chacune des possibilités de boutons et d'illustrations énumérées ci-dessus est associée par VB à une valeur entière. Dès lors, pour choisir tel jeu de bouton, il suffit d'entrer comme argument l'entier correspondant. Et pour associer tel jeu de bouton à telle illustration, il suffira d'additionner les deux valeurs correspondantes.
Là où ça devient intéressant, c'est qu'on n'est pas obligé de spécifier l'argument sous la forme d'un nombre entier. Cet entier peut donc être écrit sous une forme, celle d'une constante VB.
| Type d’icône | Bouton par défaut L’option bouton par défaut permet de définir le bouton qui sera sélectionné par défaut. | ||||||||||
| |||||||||||
| Types d’icône (membres de la classe MessageBoxIcon) | |||||||||||
| Constante | Aperçu | ||||||||||
| Error | |||||||||||
| Exclamation | |||||||||||
| Information | |||||||||||
| Question | |||||||||||
Exemple 1
, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1) If("Continuer ?","Confirmation", MessageBoxButtons.YesNo) =Then
("On a choisi Oui ")
Else
("On a choisi Non ")
EndIf
Exemple 2
PrivateSubButton1_Click(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)
HandlesButton1.Click, Button2.Click
'En récupérant le texte écrit sur le bouton, on peut n'écrire qu'une seule procédure
Me.Visible =False
' on utilise donc la propriété text du paramètre sender i = MsgBox("On a choisi "& , vbInformation + vbOKOnly,"Excellent choix") j = MsgBox("Désirez-on choisir à nouveau ?", vbQuestion + vbYesNo,"Rejouer ?") Ifj = vbYesThen
Me.Visible =True
îte de saisie
La boîte de saisie (InputBox) permet la saisie d’une chaîne de caractère par l’utilisateur. Il est possible de paramétrer le titre, le texte affiché ainsi que le texte saisi par défaut.
InputBox est une fonction, elle retourne la valeur saisie par l’utilisateur où chaîne vide si le bouton Annuler est utilisé. La valeur retournée est toujours de type String. Les éventuels contrôle de saisie devront être fait par le programme une fois la valeur retournée.
Il s'agit d'une fonction, dont les deux arguments de type String correspondent respectivement à l'invite ("le pays le plus beau du monde?") et au titre ("Question pour un champion") de la boîte de saisie. Cette fonction renverra
toujours une valeur de type String. Pour obtenir le résultat ci-dessus, on aura donc écrit un code du genre :
Rep = InputBox(a, b)
Ce code attendra que le bouton OK (ou Annuler) soit cliqué, et stockera alors le contenu de la zone de saisie dans la variable Rep.
Exercice
Ecrire un petit programme invitant l'utilisateur à répondre correctement à la question posée, sinon il doit réessayer jusqu'obtention de la réponse voulue. Solution
Dima, repAsString a ="maroc" rep =""
While(rep <> a)
rep = InputBox("le pays le plus beau du monde??","Question pour un champion","Ma ")
Toujours est-il que la boîte de message figurant plus haut peut ainsi être programmée comme :
b ="Dernière vérification" rep = MsgBox(a, 3 + 32, b)
Ce qui n'est pas très explicite. Mais on peut tout aussi bien - et même mieux - écrire :
a =" Jeu terminé. Veut-on continuer ?" b ="Dernière vérification" rep = MsgBox(a, MsgBoxStyle.YesNoCancel + MsgBoxStyle.Question, b)
En fait, pour désigner exactement les mêmes valeurs Integer, on dispose :
d'une part des noms généraux du Framework .NET (ce sont les membres des énumérations) d'autre part des noms propres à VB (ce sont les constantes VB).
Résultat des courses, on peut tout aussi bien employer les les uns que les autres, et écrire :
a =" Jeu terminé. Veut-on continuer ?" b ="Dernière vérification" rep = MsgBox(a, vbYesNoCancel + vbQuestion, b)
Passons maintenant au résultat de la fonction Msgbox. Quelle valeur celle-ci renvoie-t-elle ? Le résultat d'une fonction Msgbox, c'est le bouton sur lequel l'utilisateur a appuyé pour la faire disparaître. Et c'est ce résultat qui sera stocké dans la variable Rep.
Sous quelle forme ce résultat s'exprime-t-il ? Sous la triple forme d'un entier correspondant au bouton en question, d'une constante VB correspondant à cet entier, ou du membre de l'énumération .NET correspondant tout à la fois à l'Integer et à la constante VB.
Un petit coup d'œil sur l'aide apprend ainsi que le clic sur le bouton OK correspond au renvoi par MsgBox de la valeur 1, autrement dit du membre ou de la constante VB vbOK. De même, le clic sur le bouton Annuler correspond au renvoi par MsgBox de la valeur 2, autrement dit du membre
MsgboxResult.Cancel ou de la constante VB vbCancel.
On aura sans doute remarqué que sous Windows, quel que soit le logiciel utilisé, ou presque, certaines commandes possèdent des airs de famille. Par exemple, lorsqu’on faites Fichier / Ouvrir, Fichier /Enregistrer, Fichier/ Imprimer, et quelques autres encore, non seulement les fonctionnalités proposées sont les mêmes, mais encore la présentation de la boîte de dialogue est rigoureusement identique d'une application à l'autre,
Lorsqu’on devra insérer une de ces "boîtes de dialogues" dans l’application, nul besoin de la programmer :
Windows, via Visual Studio, offre la possibilité d'utiliser directement son code, au travers d'une série de classes:
OpenFileDialog : correspond à la boîte de dialogue Fichier - Ouvrir
SaveFileDialog : correspond aux boîtes de dialogue Fichier - Enregistrer et Fichier - Enregistrer Sous
FolderBrowserDialog : correspond à un explorateur de répertoires (qui repère automatiquement la structure des répertoires de la machine sur laquelle tourne l'application)
FontDialog : correspond à la boîte de dialogue Police
ColorDialog : correspond à une boîte de dialogue donnant accès aux couleurs personnalisées
PrintDialog : correspond à la boîte de dialogue Fichier - Imprimer
PrintPreviewDialog : correspond à la boîte de dialogue Fichier - Aperçu avant impression
PrintPreviewControl : zone permettant d'afficher un Aperçu avant impression
PrintDocument : correspond à la boîte de dialogue Fichier - Imprimer
PageSetupDialog : correspond à la boîte de dialogue Fichier - Mise en page
Tous ces contrôles, hormis PrintPreviewControl, ne se positionnent pas sur la Form, mais en-dehors. Pour les déclencher, il suffit d'utiliser dans le code la méthode ShowDialog. Naturellement, il est possible de paramétrer ces boîtes de dialogue via leurs propriétés, et d'en récupérer les résultats, toujours via leurs propriétés.Si on observe les différentes applications tournant sous Windows, on s'apercevra qu’elles utilisent toutes les mêmes boîtes de dialogue standard (Enregistrer, Ouvrir Imprimer …).
i.Ouverture
La boîte de dialogue d’ouverture permet la sélection d’un ou plusieurs fichiers physiques. La classe « OpenFileDialog » permet la gestion de cette boîte de dialogue.
Le code suivant paramètre la boîte de dialogue en acceptant uniquement les fichiers images (gif ou jpg). La sélection multiple est autorisée et la liste des fichiers est affichée à la fin:
PrivateSubForm1_Load(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesMyBase.Load
DimdlgAsOpenFileDialog dlg =NewOpenFileDialog'paramétrage de la boîte dlg.Title ="Veuillez sélectionner l'image" dlg.DefaultExt ="gif" dlg.Filter ="Image gif|*.gif|Image Jpeg|*.jpg" dlg.Multiselect =True dlg.CheckFileExists =True'affichage de la boite dlg.ShowDialog()
ForEachfichierIndlg.FileNames
MsgBox(fichier)
FARIH Saïd
ii.Enregistrement
La boîte de dialogue d’enregistrement est identique à la boîte de dialogue d’ouverture exceptée la propriété « Méthode » qui disparaît. Pour ouvrir une boîte d’enregistrement, utiliser la classe « SaveFileDialog »:
PrivateSubForm1_Load(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesMyBase.Load
DimdlgAsSaveFileDialog dlg =NewSaveFileDialog 'paramétrage de la boîte
dlg.Title ="Enregistrer le fichier" dlg.DefaultExt ="gif" dlg.Filter ="Image gif|*.gif|Image Jpeg|*.jpg"
'affichage de la boite dlg.ShowDialog()
MsgBox("le fichier sera enregistré dans: "& dlg.FileName) EndSub
iii.Choix d’une couleur
Cette boîte de dialogue permet à l’utilisateur de choisir une couleur dans un panel. Deux versions de cette boîte de dialogue existent :
Dans les deux cas, on doit utiliser la classe « ColorDialog ».
| Propriété | Description |
| Color | Définit la couleur par défaut affichée et retourne la couleur sélectionnée par l’utilisateur |
| Fullopen | Booléen définissant si la boîte de dialogue s’affiche en mode complet ou non |
| SolidColorOnly | Booléen n’affichant que les couleurs gérées par la carte graphique |
L’exemple suivant affiche une boîte de dialogue et modifie la couleur de fond du formulaire en fonction du choix de l’utilisateur :
PrivateSubForm1_Load(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesMyBase.Load
DimcAsNewColorDialog
c.FullOpen =False
c.Color =Me.BackColor
c.ShowDialog()
Me.BackColor = c.Color
EndSub iv.Choix d’une police
Cette boîte de dialogue permet la sélection de tous les paramètres concernant le formatage de chaîne de caractère (police, taille, gras…).
FARIH Saïd
On retrouve pour les contrôles créés à partir de la classe Button les propriétés générales déjà évoquées cidessus pour les Form : Name, bien sûr, mais aussi Text, Size, Location, Visible et bien d'autres.
Si la classe Button on intéresse, ce n'est pas tant pour ses propriétés que pour sa capacité à gérer un certain nombre d'événements, à commencer par le plus fréquent d'entre eux : Click. On va donc pouvoir gérer des procédures déclenchées automatiquement par le clic sur un bouton,
Exercice 1
PrivateSubB1_Click(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesB1.Click
If= 24Then
= 104
Else
= 24
EndIfEndSub EndClass
Exercice 2
PrivateSubButton1_Click(ByValsenderAsSystem.Object,ByValeAsSystem.EventArgs)HandlesButton1.Click
Button1.Visible =False Button2.Visible =True
PrivateSubButton2_Click(ByValsenderAsSystem.Object,
ByValeAsSystem.EventArgs)HandlesButton2.Click
Button2.Visible =False
Button1.Visible =True
EndSubEndClass
Le Label correspond à une simple étiquette posée sur une Form (généralement, pour éclairer l'utilisateur sur tel ou tel point, commenter une image ou une zone, etc.) Il est généralement utilisé pour afficher le rôle des différents contrôles.
Il ne s'agit pas de zones de saisie pour l'utilisateur c'est-à-dire qui ne sera pas éditable par l’utilisateur. Ce qui n'empêche pas le contenu d'un Label de pouvoir être modifié par le code en cours d'exécution, ni le Label de pouvoir recevoir un certain nombre d'événements, dont le Click. Signalons toutefois trois propriétés que possède la classe Label :
FARIH Saïd
