L’interface Utilisateur
Elle correspond aux fenêtres et contrôles que voit l'utilisateur.
On a vu que le développeur dessine cette interface en mode conception (Design) dans l'IDE.
Rappel :
Comment créer une fenêtre ?
Menu Projet, Ajouter un formulaire Windows, cliquer sur WindowsForm, une fenêtre ‘Form1’ apparaît. On a bien crée une fenêtre avec la classe (En fait on a crée une Classe 'Form1').
Comment ajouter un bouton ?
Cliquer sur ‘Boite à Outils’ à gauche , bouton WindowsForms, puis bouton ‘Button’,cliquer dans Form1, déplacer le curseur sans lâcher le bouton, puis lâcher le bouton : un bouton apparaît.
Comment ajouter un label ?
Un label est un contrôle qui permet d’afficher un texte.
Comme pour le bouton cliquer sur ‘Boite à Outils’ à gauche, bouton WindowsForms, bouton ‘Label’ et mettre un contrôle label sur la fenêtre. On obtient dans la fenêtre principale :
Modifier les propriétés de l'objet.
Il suffit ensuite de modifier les propriétés de l'objet pointé (celui qui est entouré de petit carrés) pour lui donner l’aspect désiré. Les propriétés sont accessibles dans la fenêtre depropriétés de droite.
Dans le code des procédures les propriétés des objets sont aussi accessibles. ="OK" ’permet par exemple de modifier la propriété Text d'un bouton.
Noter que pour modifier la taille des objets, on peut le faire très facilement à la souris en cliquant sur les petits carré entourant l'objet et en tirant les bords (On peut interdire les modifications de taille et de position des contrôles par le menu Format puis verrouiller les contrôles une fois que leurs tailles et positions est bien définies.).
Tous les objets ont des propriétés communes Celles héritées de la Classe ‘Control' qu’il faut connaître: 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 noms génériques, comme Form1, Form2, Form3 pour les fenêtres, List1, List2 pour les listes Accessible en mode conception uniquement.
Il est vivement conseillé, avant toute autre chose, de rebaptiser les objets que vous venez de créer afin de donner des noms plus évocateurs.
Le bouton sur lequel est écrit « OK » sera nommé BoutonOK. La liste qui affiche les utilisateurs sera nommée ListUtilisateurs.
Il est conseillé de débuter le nom de l’objet par un mot évoquant sa nature : BoutonOk ou BtOk ou ButtonOk, btnOk ‘c’est comme vous voulez.
Microsoft conseille :
|
- Btn |
pour les Boutons |
|
- Lst |
pour les ListBox |
|
- Chk |
pour les CheckBox |
|
- Cbo |
pour les combos |
|
- Dlg |
pour les DialogBox |
|
- Frm |
pour les Form |
|
- Lbl |
pour les labels |
|
- Txt |
pour les Textbox |
|
- Tb |
pour les Toolsbar |
|
- Rb |
pour les radiobutton |
|
- Mm |
pour les menus |
|
- Tmr |
pour les timers |
Text : il s’agit du texte qui est associé à l’objet.
Dans le cas d’une fenêtre c’est le texte qui apparaît dans la barre de titre en haut.
Pour un TextBox ou un Label c’est évidement le texte qui est affiché.
On peut modifier cette propriété en mode conception ou dans le code :
Exemple : Avec du code comment faire pour que le bouton ButtonOk porte l’inscription ‘Ok’ = "Ok"
Enabled : accessible Indique si un contrôle peut répondre à une interaction utilisateur.
La propriété Enabled permet l'activation ou la désactivation des contrôles au moment de l'exécution. Vous pouvez désactiver les contrôles ne s'appliquant pas à l'état actuel de l'application. Vous pouvez également désactiver un contrôle pour interdire son utilisation. Par exemple, un bouton peut être désactivé pour empêcher l'utilisateur de cliquer dessus. Si un contrôle est désactivé, il ne peut pas être sélectionné. Un contrôle désactivé est généralement gris.
Exemple : désactiver le ButtonOk ButtonOk.Enabled=False
Visible :
Indique si un contrôle est visible ou non. ButtonOk.Visible=False ‘fait disparaître le bouton.
Attention pour rendre visible une fenêtre on utilisa la méthode .Show.
Font :
Permet le choix de la police de caractères affichée dans l’objet.
BackColor ForeColor :
Couleur du fond, Couleur de l’avant plan
Pour un bouton Forecolor correspond au cadre et aux caractères. ButtonOk.ForeColor=
Tag :
Permet de stocker une valeur ou un texte lié à l'objet. Chaque objet a un Tag qui peut contenir du texte. On l'utilise souvent comme un Flag lié à l'objet.
Par exemple: une liste peut contenir la liste des CD ou des DVD ou des K7, quand je charge la liste des CD, je rajoute ="CD" cela permet ultérieurement de voir ce qu'il y a dans la liste.
Il y a bien d'autres propriétés.
On a vu que les objets de l'interface utilisateur ont des procédures déclenchées par les évènements de cet objet.
2 exemples :
- Quand l'utilisateur clique sur un bouton Ok, la procédure ButtonOk_Click s'effectue.
- Quand l'état (coché ou non coché) d'une case à cocher nommée CouleurRouge change, la procédure CouleurRouge.CheckedChanged est activée.
La syntaxe complète de la procédure est:
Private Sub CouleurRougeCheckedChanges (ByVal sender As System.Objet, ByVal e As System.EventArgs) Handles CouleurRouge.CheckedChanged
End Sub
Détaillons : La procédure évènement est privée (Private).
Après le nom Sub il y a un nom de procédure (CouleurRougeCheckedChanges)
Handles indique quel objet et évènement à déclenché la procédure. (On verra qu'il peut y en avoir plusieurs.)
A noter que Sender contient le contrôle ayant déclenché l'évènement et e l'évènement correspondant.
’contient par exemple le nom du contrôle ayant déclenché l'évènement. On
voit que quand on crée un objet, ses procédures évènements sont automatiquement crées.
On se rend compte que dans une procédure évènement on peut modifier (en mode conception) ou lire (en mode Run) quel objet et quel évènement a déclenché la procédure. On peut même indiquer plusieurs objets liés à cette procédure.
Certains évènements sont communs à tous les contrôles :
- Click
- DoubleClick
- GotFocus
- LostFocus
- KeyUp
- KeyPress - KeyDown
Il y a toujours des méthodes Changed déclenchées par un changement d'état : CheckedChanged pour une case à cocher, TextChanged pour un contrôle texte.
Pour ne pas alourdir les exemples, nous écrivons souvent une version simplifiée de l'en-tête de la procédure.
En résumé :
Le programmeur dessine les fenêtres et contrôles. Il peut modifier les propriétés des objets dessinés :
- Par la fenêtre de propriétés (en mode conception).
- Par du code (des instructions) dans les procédures.
Elles correspondent aux fenêtres ou 'formulaires'.
Créer une fenêtre en mode conception :
Menu Projet, Ajouter un formulaire Windows, cliquer sur WindowsForm, une fenêtre ‘Form1’ apparaît. On a bien crée une fenêtre avec la classe WindowsForms. Toute l’interface se trouve sur des fenêtres. En on parle de formulaire.
Bien sur, la fenêtre possède des propriétés qui peuvent être modifiées en mode design dans la fenêtre 'Propriétés' à droite ou par du code:
Name : Nom du formulaire.
Donner un nom explicite, par exemple ‘FrmDemarrage’
Dès qu’une fenêtre est créée on modifie immédiatement ses propriétés en mode conception pour lui donner l’aspect que l’on désire.
Text : C’est le texte qui apparaîtra dans la barre de titre en haut. Text peut être modifié par le code : = "Fenêtre"
Icon : propriété qui permet d’associer à la Form un fichier icône. Cette icône s’affiche 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.
Comment créer une icône ?
Dans l'IDE de VB.
Menu Fichier>Nouveau>Fichier cliquez sur Icon, Vb ouvre une fenêtre Icon1 (dans l'éditeur d'images de Visual ) Cela permet de créer ou modifier une icône (Fichier>Ouvrir>Fichier pour modifier).
Comment enregistrer ? Click droit dans l'onglet 'Icon1' ouvre un menu contextuel permettant d'enregistrer votre Icône.
WindowState :
Donne l’état de la fenêtre : Plein écran (FormWindowState.Maximized), normale (FormWindowState.Normal), dans la barre de tache (FormWindowState.Minimized).
Exemple : mettre une fenêtre en plein écran avec du code.
me.WindowState =FormWindowState.Maximized
(Quand on tape Me.WindowsState= Vb donne la liste, l'énumération)
ControlBox
Si cette propriété à comme valeur False, les boutons de contrôle situés à droite de la barre de la fenêtre n’apparaissent pas.
MaximizeBox
Si cette propriété à comme valeur False, le boutons de contrôle ‘Plein écran’ situés à droite de la barre de la fenêtre n’apparaît pas.
MinimizeBox
Si cette propriété à comme valeur False, le boutons de contrôle ‘Minimize’ situés à droite de la barre de la fenêtre n’apparaît pas.
FormBorderStyle
Permet de choisir le type des bords de la fenêtre : sans bord (None), bord simple (FixedSingle) ne permettant pas à l’utilisateur de modifier la taille de la fenêtre, bord permettant la modification de la taille de la fenêtre (Sizable)…
Exemple :
Me.FormBorderStyle =FormBorderStyle.Sizable
StartPosition :
Permet de choisir la position de la fenêtre lors de son ouverture.
Fenêtre au centre de l’écran ? À la position qui existait lors de la conception ?
Me.StartPosition =FormStartPosition.CenterScreen
MinSize et MaxSize
Donne les dimensions minimums et maximums que l'on peut utiliser pour redimensionner une fenêtre.
Opacity
Allant de 0% à 100%, permet de créer un formulaire plus ou moins transparent.
Exemple:
Me.FormBorderStyle= Sizable Me.ControlBox=False Donne la fenêtre :
On vient de dessiner une Form1 et une Form2 c'est donc les Class 'Form1 et 'Form2' (les moules) que l'on a dessiné.
Si dans une routine de la Form1 on veut ouvrir une seconde fenêtre de type Form2, il faut :
Créer un Objet fenêtre (formulaire) avec le moule Form2 :
Dim f As New Form2()
La nouvelle instance f de la Class 'form2' est un objet fenêtre.
Pour la faire apparaître j'utilise la méthode :.ShowDialog.
f.ShowDialog()
La fenêtre f est modale car on a utilisé ShowDialog : quand elle est ouverte, on ne peut pas aller dans une autre fenêtre de l'application avant de sortir de celle là. (A titre d'exemple les fenêtres MessageBox sont toujours Modales). Utiliser .show pour ouvrir une feuille non modale.
Attention : une fenêtre est un objet et est 'visible' suivant les règles habituelles des objets.
Si on instance une fenêtre à partir d'une procédure, elle sera visible dans cette procédure. Si elle est 'Public' et instancée dans un module standard, elle sera visible partout.
Au cours de l'exécution:
Quand la feuille est chargée la procédure Form1_Load() est activée.
On pourra donc y mettre le code initialisant la feuille.
Form1_Activated() est exécuté ensuite car la feuille deviendra active.
Form1.GotFocus() est enfin exécuté puisque la fenêtre prend le focus. Form1.Enter () est exécuté lorsque l'utilisateur entre dans la fenêtre.
Dès qu'une propriété change de valeur un évènement 'PropriétéChanged' se déclenche :
- Form1.BackColorChanged se déclenche par exemple quand la couleur du fond change.
- Form1.Resized se déclenche quand on modifie la taille de la fenêtre. (C’est intéressant pour interdire certaines dimensions)
Form1.Leave survient dans il y a perte du focus.
Bien sur il existe aussi Form1_Desactivate quand la fenêtre perd le focus et n'est plus active. Form1.Closing se produit pendant la fermeture de la fenêtre (on peut annuler cette fermeture en donnant à la variable Cancel la valeur True) Form1.Closed se produit lorsque la fenêtre est fermée.
Il y en a beaucoup d'autres comme par exemple les évènements qui surviennent quand on utilise la souris (MouveUp, MouseDown, MouseMove) ou le clavier (KeyUp, KeyDown, KeyPress) sur la fenêtre, Left Right, Size, Position pour positionner la fenêtre ou définir sa taille…
On a déjà vu que pour faire apparaître une fenêtre il faut utiliser .ShowDialog (pour qu'elle soit modale) ou .Show (pour non modale).
Me.Close ‘ferme le formulaire.
Me.Activate ‘l'active s'il est visible
‘rend la fenêtre invisible.
On se rend compte que quand on dessine une fenêtre Form2 par exemple, VB crée une nouvelle classe 'Class Form2'
Public Class Form2 End Class
Elle hérite de , on voit bien dans le code :
Inherits
Elle contient :
- du code généré automatiquement par le concepteur Windows Forms (on peut le voir en cliquant sur le petit '+') et qui crée la fenêtre et ses contrôles. - les procédures liées aux évènements.
Quand on tape Dim f As New Form2(), on crée une instance de la Class Form2.
Pour définir au moment de la conception un formulaire en tant que formulaire d'avant-plan d'une application :
- Dans la fenêtre Propriétés, attribuez à la propriété TopMost la valeur true.
Pour définir par code un formulaire en tant que formulaire d'avant-plan d'une application :
- Dans une procédure, attribuez à la propriété TopMost la valeur true.
Me.TopMost = True
Ils sont omniprésents dans les 'formulaires'.
Créer un bouton :
Cliquer sur ‘Boite à Outils’ à gauche , bouton Windows Forms, puis bouton ‘Button’,cliquer dans Form1, déplacer le curseur sans lâcher le bouton, puis lâcher le bouton : un bouton apparaît.
Modifier ses propriétés :
Name est utilisé pour lui donner un nom explicite (BoutonOk BoutonCancel)
FlatStyle donne un aspect au bouton (Flat, standard, System)
Text contient le texte à afficher sur le bouton. ForeColor correspond à la couleur de ce texte (BackColor étant la couleur du fond)
Si on y inclut un « & » la lettre qui suit sera souligné et sert de raccourci clavier. &Ok donne sur le bouton Ok.
TextAlign permet de positionner le texte dans le bouton.
Image contient le nom de l’image à afficher sur le bouton (si on veut afficher une image, on le fait en mode Design; noter que quand on distribue l'application, il n'y a pas besoin de fournir le fichier contenant l'image avec l’application). (AlignImage permet de positionner l’image sur le bouton.)
On peut aussi puiser une image dans une ImageList grâce à la propriété ImageList et ImageIndex, on peut ainsi changer d’image.
La propriété BackGroundImage permet de mettre une image de fond.
Exemple :
="Ok" ’affiche 'Ok' dans le bouton.
Utiliser les évènements :
L’évènement principalement utilisé est Click() : quand l’utilisateur clique sur le bouton la procédure est traitée.
Private Sub Button_Click(..)
End Sub
Cette procédure contient le code qui doit être exécuté lorsque l'utilisateur clique sur le bouton. Le bouton peut être sélectionné grâce à un clic de souris, à la touche ENTRÉE ou à la BARRE D'espacement si le bouton a le focus.
Créer un bouton Ok ou Cancel :
Parfois il faut permettre aux utilisateurs de sélectionner un bouton en appuyant sur la touche ENTRÉE même si le bouton n'a pas le focus.
Exemple : Il y a sur la fenêtre un bouton "Ok" qui doit être enfoncé quand l'utilisateur tape 'Enter' au clavier, c'est le bouton qui 'valide' le questionnaire ( et qui le ferme souvent).
Comment faire?
Définissez la propriété AcceptButton de la Form en lui donnant le nom du bouton. Cela permet au formulaire d'avoir le comportement d'une boîte de dialogue.
Création d'un bouton par code :
L'exemple suivant crée un Button nommé Button1 sur lequel on voit "Ok", on modifie certaines de ses propriétés et l'ajoute à Form.
Private Sub InitializeMonButton() Dim button1 As New Button1() ="Ok"
' Ajouter le bouton à la Form
(button1)
End Sub
Il faut par code créer aussi les évènements liés à ce bouton: dans ce cas il faut déclarer le bouton plutôt avec la syntaxe contenant WithEvents et en haut du module.
Private WithEvents Button1 As Button
Puis écrire la sub évènement.
Sub OnClique ( sender As Objet, EvArg As EventArgs) Handles Button1
End Sub
Ainsi VB sait que pour un évènement sur le Button1, il faut déclencher la Sub OnClique. (On reviendra sur cela)
Couleur transparente dans les images des boutons:
On a vu qu'on pouvait mettre une image dans un bouton, il faut pour cela donner à la propriété Image le nom du fichier contenant l'image, ceci en mode Design.
Mais l'image est souvent dans un carré et on voudrait ne pas voir le fond (rendre la couleur du fond transparente)
Voici l’image , je voudrais ne pas afficher le 'jaune' afin de voir ce qu'il y a derrière et
donner l'aspect suivant
Dans Visual Basic 6.0, la propriété MaskColor était utilisée pour définir une couleur qui devait devenir transparente, permettant ainsi l'affichage d'une image d'arrière plan.
Dans Visual Basic .NET, il n'existe pas d'équivalent direct de la propriété MaskColor!!!
Cependant, on peut ruser et définir la transparence :
Dans le " Code généré par le Concepteur Windows Form " après la définition du bouton ou dans Form_Load ajouter:
Dim g As New System.Drawing.Bitmap(Button1.Image) g.MakeTransparent(System.Drawing.Color.Yellow)
Button1.Image = g
On récupère le Bitmap de l'image du bouton, on indique que le jaune doit être transparent, on remet le BitMap.
Bien sur il y a intérêt à choisir une couleur (toujours la même) qui tranche pour les fonds de dessin et ne pas l'utiliser dans le dessin lui même.
Les contrôles permettant de saisir du texte sont :
Les TextBoxLes RichTexteBox
Contrôle qui contient du texte qui peut être modifié par l'utilisateur du programme. C'est la propriété Text qui contient le texte qui a été tapé par l'utilisateur.
Exemple très simple : Comment demander son nom à l'utilisateur ?
Il faut créer un label dont la propriété Text contient "Tapez votre nom:", suivi d'un TextBox nommé txtNom avec une propriété Text="" (Ce qui fait que la TextBox est vide), enfin un bouton nommé btOk dont la propriété Text="Ok".
Cela donne :
|
Ok |
Tapez votre nom:
txtNom.Select() dans Form_Load donne le focus à la TextBox Une fois que l'utilisateur a tapé son nom, il clique sur le bouton 'Ok'.
Dans la Sub btOk_Click il y a: Dim Nom As String Nom=
La variable Nom contient bien maintenant le nom de l'utilisateur.
Un TextBox correspond à un mini éditeur de texte. (Mais sans enrichissement: sans gras, ni italique…) La police de caractères affectant la totalité du texte peut simplement être modifiée par la propriété Font. La couleur du texte peut être modifiée par ForeColor, mais la totalité du texte aura la même couleur.
La propriété .text permet aussi de modifier le texte visible dans le contrôle. ="Bonjour" ‘Affiche ‘Bonjour’ dans le contrôle.
Parmi les multiples propriétés de ce contrôle, signalons :
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.
TextBox1.MaxLength= 3 'limite la saisie à 3 caractères.
TextBox1.MaxLength= 0 'ne limite pas la saisie. TextLength : donne la longueur du texte
En mode MultiLine la collection Lines contient dans chacun de ses éléments une des lignes affichées dans le contrôle :
TexBox1.Lines(0) ‘contient la première ligne TexBox1.Lines(1) ‘la seconde
Les TextBox contiennent une méthode Undo, annulation de la dernière modification. La propriété CanUndo du TextBox doit être à True.
Ensuite pour modifier:
If textBox1.CanUndo = True Then ()
' Vider le buffer Undo. textBox1.ClearUndo()
End If
Ajouter au texte :
On peut ajouter du texte au texte déjà présent dans le TextBox textBox2.AppendText(MonText)
C'est équivalent à +MonText
Evènements liés aux TextBox :
- KeyDown survient quand on appuie sur la touche.
- KeyPress quand la touche est enfoncée. - KeyUp quand on relâche la touche.
Ils surviennent dans cet ordre.
KeyPress permet de récupérer la touche tapée dans e.KeyChar. KeyDown et KeyUp permettent aussi de voir si MAJ ALT CTRL ont été pressés.
On peut récupérer la touche pressé (dans e.KeyChar), mais impossible d'en modifier la valeur (e.KeyChar est en lecture seule par exemple)
Comment récupérer la totalité du texte qui est dans le TextBox ?
T=
Comment mettre les lignes saisies par l'utilisateur dans un tableau ? Dim tempArray() as String
tempArray = textBox1.Lines 'On utilise la collection Lines
Comment récupérer la première ligne ?
T= textBox1.Lines(0)
Si une partie du texte est sélectionnée par l'utilisateur, on peut la récupérer par :
T= TexBox1.SelectedText
Pour sélectionner une portion de texte on utilise TextBox1.SelectionStart=3 'position de départ
TextBox1.SelectionLength=4 'nombre de caractère sélectionné
On peut aussi écrire : TextBox1.Select(3,4)
puis
TexBox1.SelectedText="toto" 'remplace la sélection par 'toto' Comment positionner le curseur après le troisième caractère ?
En donnant à la propriété SelectionStart la valeur 3
TextBox1.SelectionStart=3
SelectionLength doit avoir la valeur 0
Comment interdire la frappe de certains caractères dans une TextBox?
Exemple :
Ne permettre de saisir que des chiffres.
Pour cela il faut utiliser l'évènement KeyPress du textBox qui retourne un objet e de type KeyPressEventArgs. e.KeyChar contient le caractère pressé, mais il est en lecture seule!! on ne peut le modifier. Pour annuler la frappe (dans notre exemple si le caractère n'est pas un chiffre) il faut faire e.handled=True. IsNumeric permet de tester si le caractère est numérique.
Private Sub TextBox1_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox1.KeyPress
If IsNumeric(e.KeyChar) Then
e.Handled = False
Else
e.Handled = True
End If End Sub
Compter combien de fois on a tapé certains caractères?
Private Sub TextBox1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles TextBox1.KeyPress
Select Case e.KeyChar
' Compte les backspaces.
Case
Nombrebackspace = Nombrebackspace + 1
' Compte les ‘ENTER’.
Case
Nombrereturn = Nombrereturn + 1
' Compte les ESC.
Case Convert.ToChar(27)
NombreEsc = NombreEsc + 1
' Compte les autres.
Case Else keyPressCount = keyPressCount + 1
End Select End Sub
Petite parenthèse:
Pour comparer les caractères il y a 2 méthodes:
if e.KeyChar=Convert.ToChar(27) then
ou if AscW(e.Keychar)=27 then Différentes manières de récupérer ce qui a été tapé :
On a vu que contient la totalité du texte; si on l'utilise dans l'évènement TextBox1_TextChanged, on récupère le nouveau texte dès que l'utilisateur à tapé quelque chose.
TextBox1_KeyPress() et TextBox1_KeyUp() permettent de récupérer le caractère qui à été tapé.
Y a t-il un moyen de modifier le caractère tapé ? Les propriétés de e comme e.KeyChar (dans KeyPress) ou e.KeyCode, e.KeyData e.KeyValue dans les évènements KeyPress et KeyDown sont en lecture seule!!!
Une solution est de modifier directement le texte :
Exemple :
Si l'utilisateur tape ',' afficher '.' à la place.
Private Sub TextBox1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles TextBox1.KeyPress Dim pos As Integer
pos = TextBox1.SelectionStart 'on mémorise la position du curseur
If e.KeyChar = "," Then
e.Handled = True 'on ne valide pas le caractère ',' qu n'apparaîtra pas. = .Insert(pos, ".") 'on insère un '.'
TextBox1.SelectionStart = pos + 1 'on avance le curseur d'un caractère End If
End Sub
Autre solution?
Si vous êtes débutant, passez à un rubrique suivante, vous reviendrez plus tard à la gestion du code RTF. Rich Text veut dire 'Texte enrichi'.
Le contrôle RichTextBox permet d'afficher, d'entrer et de manipuler du texte mis en forme. Il effectue les mêmes tâches que le contrôle TextBox, mais il peut également afficher des polices, des couleurs et des liens, charger du texte et des images incorporées à partir d'un fichier, ainsi que rechercher des caractères spécifiques.
Le contrôle RichTextBox a les possibilités d’un traitement de texte comme Word.
Qu'est ce que RTF ?
Le format du texte que l’on peut mettre dans une RichTextBox est le format RTF (Rich Text Format = Format de Texte Enrichi)
Explication : un texte peu être enregistré en brut (sans enrichissements) en RTF (Utilisable dans la plupart des traitements de texte), au format Word (.doc)…
Pour utiliser les fonctionnalités du RichTextBox il faut utiliser la propriété .Rtf. Quand j’affecte un texte à la propriété .Text il est affiché tel quel, sans tenir compte de l’enrichissement.
Quand j’affecte un texte à la propriété .Rtf du contrôle pour l’afficher, s'il contient des enrichissements au format RTF, l’enrichissement est affiché.
Les bases du codage RTF
Le texte doit débuter par '{' et se terminer par '}', il peut aussi débuter par "{\rtf1\ansi " Ensuite les enrichissements s’effectuent par des balises qui indiquent le début et la fin de l’attribut, une balise commence par le caractère '\' : Entre \b et \b0 le texte sera en gras (Bold)
Exemple :
Ajoute le texte "Ce texte est en gras." à un contrôle RichTextBox existant.
= "{\rtf1\ansi Ce texte est en \b gras\b0.}"
Voici les principaux attributs :
\b \b0 ce qui est entre les 2 balises est en gras
\i \i0 ce qui est entre les 2 balises est en italique
\par fin paragraphe (passe à la ligne)
\f font \f1 .. \f0 font numéro 1 entre les 2 balises
\plain ramène les caractères par défaut
\tab caractère de tabulation
\fs taille de caractère \fs28 = taille 28
Mettre un espace après la balise.
Comment afficher un texte enrichir ?
= T 'T étant le texte enrichi Mettre un texte en couleurs, utiliser plusieurs polices :
Mettre la table des couleurs en début de texte :
{ \colortbl \red0\green0\blue0;\red255\green0\blue0;\red0\green255\blue0;}
Après Colortbl (Color Table) chaque couleur est codée avec les quantités de rouge vert et bleu. Les couleurs sont repérées par leur ordre: couleur 0 puis 1 puis 2 et séparées par un ';'
Dans notre exemple couleur 0=noir; couleur 1=rouge; couleur 2=vert
Pour changer la couleur dans le texte on utilise \cf puis le numéro de la couleur : « \cf1 toto \cf0 } » ‘toto est affiché en rouge.
Pour modifier les polices de caractère, le procédé est similaire avec une Font Table :
{\fonttbl
{\fo\froman Symbol;}
{\f1\fswiss Arial;}
}
Pour passer en Arial \f1 ..\f0
Exemple complet :
"{\rtf1\ansi
{ \colortbl
\red0\green0\blue0;
\red255\green0\blue0;
\red0\green255\blue0;}
{\fonttbl
{\fo\froman Symbol;}
{\f1\fswiss Arial;}
}
Ce qui suit est en \f1 \cf1 \i Arial Rouge Italique \f0 \cf0 \i0
}» Cela donne :
Nb : Si vous copier coller l’exemple pour l’essayer, enlever les sauts à la ligne.
Comment modifier l’aspect du texte qui a été sélectionné ?
On n’est plus dans le cas ou on affiche d’emblée la totalité du texte, mais dans le cas ou l’utilisateur veut modifier son texte qui est déjà dans le contrôle.
Exemple :
L’utilisateur sélectionne une portion du texte dans le contrôle puis clique sur une bouton nommé ’Rouge’ pour mettre la sélection en rouge.
Dans BoutonRouge_Click() écrire :
RichTextBox1.SelectionColor =
De même pour modifier la police, la hauteur de la police, l’aspect gras ou non :
RichTextBox1.SelectionFont = New Font("Tahoma", 12, )
Enfin le texte peut être enregistré dans un fichier :
richTextBox1.SaveFile(FileName, RichTextBoxStreamType.RichText)
Si on remplace .RichText par .PlainText c’est le texte brut et non le texte enrichi qui est enregistré. Pour lire un fichier il faut employer .LoadFile avec la même syntaxe.
Comment faire une recherche dans le texte?
La fonction Find permet de rechercher une chaîne de caractères dans le texte :
(searchText, searchStart, searchEnd, RichTextBoxFinds.MatchCase)
La méthode retourne l'emplacement d'index du premier caractère du texte recherché et met en surbrillance ce dernier, sinon, elle retourne la valeur -1.
Les ‘Label’ : On en a déjà utilisé pour afficher du texte non modifiable par l'utilisateur.
Les contrôles Label sont généralement utilisés pour fournir un texte descriptif à un contrôle. Vous pouvez par exemple utiliser un contrôle Label pour ajouter un texte descriptif à un contrôle TextBox.
Ceci a pour but d'informer l'utilisateur du type de données attendu dans le contrôle.
Exemple hyper simple :
Donner votre nom:
La légende qui s'affiche dans l'étiquette est contenue dans la propriété Text du label1.
Pour modifier le texte du label par du code :
="Donner votre Prénom"
La propriété Alignement vous permet de définir l'alignement du texte dans l'étiquette (centré, à droite, à gauche), BorderStyle permet de mettre une bordure (un tour) ou non..
Il est également possible d’y afficher une image avec la propriété .Image
Remarquez que la mise à jour de l'affichage du Label (comme les autres contrôles d'ailleurs) est effectuée en fin de Sub:
Si on écrit :
Dim i As Integer
For i = 0 To 100
= i.ToString
Next i
La variable i prend les valeurs 1 à 100, mais à l'affichage rien ne se passe pendant la boucle, VB affiche uniquement 100 à la fin.
Si on désire voir les chiffres défiler avec affichage de 0 puis 1 puis 2 , il faut rafraîchir l'affichage à chaque boucle avec la méthode Refresh() :
Dim i As Integer
For i = 0 To 100
= i.ToString: Label1.Refresh() Next i
Les LinkLabel : Permettent de créer un lien sur un label.
Text Indique le texte qui apparaît.
LinkArea défini la zone de texte qui agira comme un lien, dans la fenêtre de propriété taper 11 ;4 (on verra que c’est plus simple que de le faire par code) Les 4 caractères à partir du 11ème seront le lien, ils seront soulignés.
Ne pas oublier comme toujours que le premier caractère est le caractère 0.
L’événement LinkClicked est déclenché quand l’utilisateur clique sur le lien. Dans cette procédure on peut permettre le saut vers un site Internet ou toute autre action.
Exemple :
= "Visitez le site LDF"
LinkLabel1.LinkArea = New System.Windows.Forms.LinkArea(11, 4) ‘Pourquoi faire simple !!
Cela affiche :
Si l’utilisateur clique sur le mot site, la procédure suivante est déclenchée :
Private Sub LinkLabel1.LinkClicked… Il est possible de modifie la couleur du lien pour indiquer qu'il a été utilisé :
Si VisitedLinkColor contient une couleur e.visited=True modifie la couleur. (e est l'élément qui a envoyer l'évènement, j'en modifie la propriété Visited.)
On peut y inclure une action quelconque, en particulier un saut vers un site Web : System.diagnostics.Process.Start(" ")
'correspond au code qui ouvre un browser Internet (Internet Explorer ou Netscape) et qui charge la page dont l'adresse est indiquée.
La collection Links permet d’afficher plusieurs liens dans un même texte, mais cela devient vite très compliqué.
Il y a 2 sortes de case à cocher :
• Les " cases à cocher " (CheckBox) : Elles sont carrées, et indépendantes les unes des autres, si l'utilisateur coche une case , cela n'a pas d'influence sur les autres cases du formulaire, qu'elles soient regroupées dans un cadre pour faire plus joli ou non.
• Les " boutons radio " (RadioButton) : Ils sont ronds et font toujours partie d’un groupe (Ils sont dans une fenêtre ou dessinés dans un objet GroupBox). Ce groupe est indispensable, car au sein d’un groupe de RadioButton, un seul bouton peut être coché à la fois : si l’utilisateur en coche un, les autres se décochent.
Il faut regrouper les radios boutons dans des 'GroupBox' par exemple pour rendre les groupes indépendants :
Ici si je clique sur le bouton 'OUI' à droite, cela décoche 'NON' mais n'a pas d'influence sur le cadre Format.
La propriété Text, bien sur, permet d’afficher le libellé à coté du bouton, on peut aussi mettre une image avec la propriété Image. CheckAlign permet de mettre la case à cocher à droite ou à gauche du texte, TextAlign permet d'aligner le texte.
Exemple pour le bouton en haut à droite :
= "OUI"
RadioButton3.TextAlign = MiddleCenter 'Middle=hauteur, center = horizontale RadioButton3.CheckAlign = MiddleRight
La propriété la plus intéressante de ces cases est celle qui nous permet de savoir si elle est cochée ou non. Cette propriété s’appelle Checked. Sa valeur change de False à True si la case est cochée.
RadioButton.Checked = True 'Coche le bouton
If RadioButton.Checked = True Then ' Teste si le bouton est coché. End If
La procédure RadioButton.CheckedChange() permet d’intercepter le changement d’état d’un bouton.
Pour le CheckButton TreeState permet de définir 3 états au lieu de 2 (coché, indéterminé = grisé, non coché) CheckedState indique un des 3 états (alors que Checked n’en indique que deux.)
Appearancepeut aussi donner une apparence de bouton à la case à cocher. Il est enfoncé
ou pas en fonction de la valeur de Checked.
Ici les 2 boutons ont une Appearance = Button, celui du haut n'est pas coché, l'autre est coché (enfoncé).
Il y a 4 sortes de listes : - Les ListBox - Les CheckedListBox - Les Combos - Les ListView
Le contrôle ListBox affiche une liste d'éléments (d'objets) dans laquelle l'utilisateur peut faire un ou plusieurs choix.
La liste contient "tarte", "poisson", "viande", "légumes", "sauces". Ici l'élément "poisson" est sélectionné, il est en bleu. La listBox contient une collection d'"Item":
Elle n’a pas de nombre initialement défini d’élément.
Si j'ajoute un élément à la ListBox, cela ajoute un élément à la collection Items
Items est une collection contenant tous les éléments (les objets) chargés dans la liste. ListBox1.Items est la collection du contrôle ListBox1 La propriété Items.Count indique le nombre d'éléments contenus dans la liste.
Attention le premier élément est toujours l’élément 0, aussi le nombre d’éléments est égal au numéro de l'élément le plus haut plus un.
Pour ajouter ou supprimer des éléments dans un contrôle ListBox.
Utilisez la méthode , Items.Insert, Items.Clear ou Items.Remove. En mode conception, vous pouvez également utiliser la propriété Items.
Exemples :
Vider la ListBox :
ListBox1.Items.Clear()
Ajouter l'élément "poisson"
("poisson")
Ajouter '4'
(4.Tostring) ou (4) 'accepté car les items sont des objets.
Insérer 'lulu en 4éme position
ListBox1.Items.Insert(4, "lulu")
Les listBox acceptent des objets, elles affichent généralement ce qu'il y a dans la propriété 'Text' de l'objet.
Charger dans une ListBox1 les nombres de 1 à 100 :
For i = 1 To 100
(i.ToString)
Next i
Comment enlever des éléments ?
ListBox1.Items.RemoveAt(5) ' Enlever l'élément d'index 5.
ListBox1.Items.Remove(ListBox1.SelectedItem) ' Enlever l'élément sélectionné ListBox1.Items.Remove("Tokyo") ' Enlever l'élément "Tokyo".
Comment lire l'élément 3 ?
T=ListBox1.Items(3).ToString
Comment rechercher l'élément qui contient une chaîne de caractères ?
List1.FindString("pa") ‘ retourne le numéro du premier élément commençant par
'pa'.
x=List1.FindString("pa",12) ‘retourne le numéro de l'élément commençant par 'pa' en cherchant à partir du 12 éme élément. x=List1.FindStringExact("papier") 'permet de rechercher l'élément correspondant exactement à la chaîne.
Comment sélectionner un élément par code ?
ListBox1.SetSelected(x, True)
L’utilisateur double-clique sur un des éléments, comment récupérer son numéro ?
Grâce à SelectedIndex.
Private Sub ListBox_DoubleClick. N=ListBox1.SelectedIndex
End If
‘N contient le numéro de l’élément sélectionné. Attention comme d’habitude, si je sélectionne « 3 » c’est en faite l’élément numéro 2.
SelectedIndex retourne donc un entier correspondant à l'élément sélectionné dans la zone de liste. Si aucun élément n'est sélectionné, la valeur de la propriété SelectedIndex est égale à - 1.
La propriété SelectedItem retourne l'élément sélectionné ("poisson" dans l'exemple si dessus).
Et la multi sélection, quels éléments ont été sélectionnés ?
La propriété SelectionMode indique le nombre d'éléments pouvant être sélectionnés en même temps.
Lorsque plusieurs éléments sont sélectionnés, la valeur de la propriété SelectedIndex correspond au rang du premier élément sélectionné dans la liste. Les collections SelectedItems et SelectedIndices contiennent les éléments et les numéros d'index sélectionnés.
Si la propriété Sorted est à True, la liste est triée automatiquement.
On peut 'charger' une ListBox automatiquement avec un tableau en utilisant Datasource :
Dim LaList() As String = {"one", "two", "three"}
ListBox1.DataSource = LaList
On peut aussi utiliser AddRange :
Dim Ite(9) As System.Object
Dim i As Integer
For i = 0 To 9
Ite(i) = "Item" & i
Next i
ListBox1.Items.AddRange(Ite)
Comment connaître l'index de l'élément que l'on vient d'ajouter ? (Et le sélectionner) Dim x As Integer
x = ("Hello") List1.SelectedIndex = x
On utilise la valeur retournée (x dans notre exemple) par la méthode Add.
(NewIndex n'existe plus en )
Comment affecter à chaque élément de la liste un numéro, une clé ?
Exemple : je charge dans une ListBox la liste des utilisateurs mais quand on clique sur la liste, je veux récupérer le numéro de l'utilisateur.
Comment donc, à chaque élément de la listbox, donner un numéro (différent de l'index). En VB6 on utilisait une propriété (ListBox.ItemData()) pour lier à chaque élément de la listBox un nombre (une clé); cela n'existe plus en !!
Il faut utiliser les fonctions de compatibilité : VB6.SetItemData(ListBox1, 0, 123) 'pour lier à l'élément 0 la valeur 123.
Ce n’est pas simple!! Une alternative, pas très élégante :
Ajouter l'élément "toto"+chr$(9)+chr$(9)+ clé (clé n'est pas visible car les caractères tabulation l'ont affichée hors de la listbox) Quand l'utilisateur clique sur la ligne, on récupère la partie droite donc la clé.
Quand on charge une ListBox directement avec une base de données, il y a une solution pour gérer une clé.
Lorsque la propriété MultiColumn a la valeur true, la liste s’affiche avec une barre de défilement horizontale. Lorsque la propriété ScrollAlwaysVisible a la valeur true, la barre de défilement s'affiche, quel que soit le nombre d'éléments.
C’est une Listbox mais avec une case à cocher sur chaque ligne
Attention : SelectedItems et SelectedIndices ne déterminent pas les éléments qui sont cochés, mais ceux qui sont en surbrillance.
La collection CheckedItems vous donne par contre les éléments cochés. La méthode GetItemChecked (avec comme argument le numéro d'index) détermine si l’élément est coché.
Exemple :
Pour déterminer les éléments cochés dans un contrôle CheckedListBox :
Tester chaque élément de la collection CheckedItems, en commençant par 0. Notez que cette méthode fournit le numéro que porte l'élément dans la liste des éléments cochés, et non dans la liste globale. Par conséquent, si le premier élément de la liste n'est pas coché alors que le deuxième l'est, le code ci-dessous affiche une chaîne du type « Item coché 1 = Dans la liste :
2 ».
If CheckedListBox1.CheckedItems.Count <> 0 Then
'S’il y a des éléments cochés une boucle balaye les éléments cochés
'(Collection CheckedItems) et affiche le numéro de l’élément DANS LA LISTE toutes lignes.
Dim x As Integer
Dim s As String = ""
For x = 0 To CheckedListBox1.CheckedItems.Count - 1 s = s & "Item coché " & (x+1).ToString & " = " & « Dans la liste : »& CheckedListBox1.CheckedItems(x).ToString & Next x
(s)
End If
On rappelle comme toujours que quand on parle du 3eme élément cela correspond à l’index 2.
Les listes Combo (Liste combiné) possèdent deux caractéristiques essentielles par rapport aux ListBox.
Elles sont 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, cela se traduit par la présence d’une zone de texte en haut de la liste.
Elles peuvent être déroulantes ou déjà déroulée, 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, ou bien que la liste est déjà visible. C’est la propriété DropDownList qui gère cela.
La combos du bas a sa DropDownList=Simple
L’utilisateur peut donc cliquer dans la liste (ce qui met le texte cliqué dans la zone texte), ou taper un nouveau texte.
|
(méthode) ajoute un élément à une liste. |
|
|
Items.Clear |
(méthode) efface tous les éléments d’une liste. |
|
Items.Count |
(propriété) renvoie le nombre d’éléments d’une liste. |
|
Multiselect |
(propriété) permet la sélection multiple. |
|
Item.Remove |
(méthode) supprime un élément de la liste. |
|
Sorted |
(propriété) trie les éléments d’une liste. |
Comment récupérer la zone texte quand elle change ? Elle est dans la propriété Text.
On utilise l'évènement TextChanged qui se déclenche quand le texte est modifié. Private Sub ComboBox1_TextChanged(ByVal sender As Object, ByVal e As
System.EventArgs) Handles ComboBox1.TextChanged
= End Sub
De plus en plus puissant, le contrôle ListView permet d’afficher des listes multi colonnes, ou des listes avec icône ou case à cocher.
En mode conception :
La propriété View permet de déterminer l’aspect général du contrôle, elle peut prendre les valeurs :
- Details permet une liste avec sous éléments et titre de colonnes.
- Liste utilise un ascenseur horizontal.
- LargeIcon - SmallIcone
Par programmation cela donne :
= View.Details
Utilisons le mode détails (Appelé mode Rapport)
Comment remplir les en-têtes de colonnes ?
En mode conception il y a une ligne Columns, le fait de cliquer sur le bouton d’expansion (…) ouvre une fenêtre, cliquer sur ‘Ajouter’ permet d’ajouter une colonne, la propriété Text permet de donner un libellé qui apparaîtra en haut de la colonne. On peut ainsi nommer les 3 colonnes (« Nombre », « Carré », « Cube » dans notre exemple).
Par programmation cela donne :
(« Nombre », 60, )
…
Pour remplir le tableau, on pourrait, sur la ligne Items de la fenêtre des propriétés, cliquer sur … et rentrer les valeurs ‘à la main’.
En pratique on crée les colonnes, le nom des colonnes en mode conception, on remplit le tableau par programmation :
Exemple : Faire un tableau de 3 colonnes, mettre les nombres de 1 à 100 dans la première, leur carré dans la seconde, leur cube dans la troisième.
Pour chaque ligne je crée un objet ListViewItem, sa propriété Text contient le texte de la première colonne, j’ajoute à cet objet des SubItems qui correspondent aux colonnes suivantes. Enfin j’ajoute le ListViewItem au contrôle ListView. Dim i As Integer For i = 1 To 100
Dim LVI As New ListViewItem
= i.ToString
((i * i).ToString)
((i * i * i).ToString)
(LVI)
Next i
Comment intercepter le numéro de la ligne qui a été cliquée par l’utilisateur (et l’afficher) ?
Private Sub ListBox1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
Handles ListBox1.Click
= ListBox1.SelectedIndices(0).ToString
End Sub
Si la propriété MultiSelect est à False il y a, bien sur, une seule ligne sélectionnée, sinon les lignes sélectionnées sont dans la collection SelectedIndices().
Si on voulait récupérer le texte de la ligne sélectionnée, il aurait fallu utiliser :
ListBox1.SelectedItems(0)
Si la propriété GridLine est à True, des lignes matérialisant les cases apparaissent. Si la propriété CheckedBox est à True, des cases à cocher apparaissent.
Attention : si la somme des colonnes est plus large que le contrôle, un ascenseur horizontal apparaît !!
Pour ne pas voir cet ascenseur, rusez sur la largeur des colonnes (c’est le 2eme paramètre de la méthode ).
Il existe :
Ces fenêtres toutes faites facilitent le travail :
MessageBox :
Ouvre une fenêtre qui présente un message.
C’est une fonction qui affiche un message dans une boîte de dialogue, attend que l'utilisateur clique sur un bouton (Ok ou Oui-Non..), puis retourne une information qui indique le bouton cliqué par l'utilisateur.
Reponse= (TexteAAfficher,Titre, TypeBouton etIcone,
BoutonParDéfaut) Exemple :
Paramètres :
TexteAAfficher
Obligatoire. Expression String affichée comme message de la boîte de dialogue (longueur maximale 1 024 caractères). N'oubliez pas d'insérer un retour chariot si le texte est long, cela crée 2 lignes. Titre
Expression String affichée dans la barre de titre de la boîte de dialogue. Si l'argument Titre est omis, le nom de l'application est placé dans la barre de titre.
TypeBouton et Icons
Expression numérique qui représente la somme des valeurs spécifiant -le nombre et le type de boutons à afficher :
MessageBoxButtons.OKOnly Un seul bouton ‘Ok’
MessageBoxButtons.YesNo Deux boutons ‘Oui’ ‘Non’
MessageBoxButtons.OkCancel ‘Ok’ et ‘Annuler’
MessageBoxButtons.AbortRetryIgnore ‘Annule’ ‘Recommence’ ‘Ignore’
..
-le style d'icône à utiliser : MessageBox.Icons.Critical
MessageBox.Icons.Exclamation
MessageBox.Icons.Question MessageBox.Icons.Information
L'identité du bouton par défaut
MessageBox.DefaultButtons.DefaultButton1
MessageBox.DefaultButtons.DefaultButton2
Retour de la fonction :
Retourne une constante qui indique quel bouton à été pressé.
DialogResult.Cancel
DialogResult.Retry
L’ancienne syntaxe VB avec MsgBox est conservée :
Reponse= MsgBox(TexteAAfficher, TypeBouton, Titre)
Dans ce cas il faut utiliser MsgBoxStyle MggBoxIcons et MsgBoxResult pour le retour. De plus les arguments ne sont pas dans le même ordre!!
Il est conseillé d’utiliser ( qui est ) plutôt que MsgBox qui est de la compatibilité avec VB
Exemple :
(«Bonjour»)
‘Affiche le message ‘Bonjour’ avec un simple bouton ‘Ok’
Cela sert à fournir un message à l’utilisateur sans attendre de choix de sa part.
Autre exemple en ancienne syntaxe :
R=MsgBox("Continuer"& chr$(13)& "l’application?", MsgBoxStyle.YesNo, "Attention"
Affiche une MessageBox avec dans la barre de titre « Attention » ‘Affiche dans la boite :
« Continuer
l’application » (sur 2 lignes)
‘La boite a 2 boutons : ‘Oui’ ‘Non’
Exemple complet : Dim msg As String
Dim title As String
Dim style As MsgBoxStyle Dim response As MsgBoxResult msg = "Voulez vous continuer?" ' Définition du message à afficher. style = MsgBoxStyle.DefaultButton2 Or _
MsgBoxStyle.Critical Or MsgBoxStyle.YesNo 'On affiche Oui Non title = "MsgBox Démonstration" ' Définition du titre. ' Affiche la boite MsgBox.
If response = Then ' L’utilisateur a choisi Oui. ' code si l’utilisateur à cliquer sur Oui Else
' code si l’utilisateur à cliquer sur No.
End If Voila ce que cela donne :
‘On remarque que dans l’exemple, on crée des variables dans lesquelles on met le texte ou les constantes adéquates, avant d’appeler la fonction MsgBox.
C'st une fonction qui permet d’ouvrir une fenêtre qui pose une question :
Elle retourne la réponse tapée par l’utilisateur : Le retour est effectué dans une variable String.
Dim Nom As String
Nom = InputBox("Bonjour","Tapez votre nom ?") Cela donne :
On pourrait rajouter un 3eme argument=la réponse par défaut.
Si l’utilisateur clique sur le bouton annuler, une chaîne vide est retournée.
Comment afficher une boite de dialogue permettant de sélectionner un fichier (ou des fichiers) à ouvrir par exemple ?
Dans la boite à Outils, cliquez sur OpenFileDialog puis cliquez sur la fenêtre en cours : un contrôle OpenFileDialog1 apparaît sous le fenêtre.
Ouvre une boite de dialogue permettant de choisir un nom et un chemin de fichier, au programmeur d'écrire le code lisant les fichiers.
Dans le code à l’endroit ou doit s’ouvrir la fenêtre, tapez :
OpenFileDialog1.ShowDialog()
C’est suffisant pour créer une fenêtre montrant l’arborescence des fichiers et répertoires et pour que l'utilisateur choisisse un fichier, mais le plus souvent on a besoin que la boite de dialogue propose un type de fichier et un répertoire précis.
Par exemple je veux ouvrir un fichier .TXT dans le répertoire c:\MesTextes
Il faut dans ce cas, AVANT le ShowDialog renseigner certaines propriétés du contrôle OpenFileDialog1 :
With OpenFileDialog1
.Filter="Fichiers txt|*.txt" ' on travaille uniquement sur les .txt
'S’il y a plusieurs filtre les séparer par |
.Multiselect=False 'sélectionner 1 seul fichier
.CheckFileExists=True 'Message si nom de fichier qui n'existe pas. 'Permet d'ouvrir uniquement un fichier qui existe End With
Comment afficher la boite et vérifier si l'utilisateur à cliqué sur ouvrir ? If OpenFileDialog1.ShowDialog= Then end if
Maintenant, OpenFileDialog1.FileName contient le nom du fichier sélectionné (avec extension et chemin)
Path.GetFileName(OpenFileDialog1.FileName) donne le nom du fichier sans chemin.
Boite de dialogue fonctionnant de la même manière que OpenFileDialog mais avec quelques propriétés spécifiques.
Ouvre une boite de dialogue permettant à l'utilisateur de choisir un nom et un chemin de fichier, au programmeur d'écrire le code enregistrant les fichiers.
SaveFileDialo1.CreatePrompt= True ' Message de confirmation si
'création d'un nouveau fichier
SaveFileDialo1.OverwritePrompt=True 'Message si le fichier existe déjà
'évite l'effacement d'ancienne données SaveFileDialo1.DefaultExt="txt" 'extension par défaut
On récupère aussi dans .FileName le nom du fichier si la propriété .ShowDialog à retourné .
Il existe aussi :
- LoadDialog - PrintDialog
On peut regrouper des contrôles dans :
- Les GroupBox.
- Les Panels.
- Les PictureBox.
- Les TabControl.
Il est possible de regrouper des contrôles dans un container, on peut par exemple regrouper plusieurs RadioButton. Le container peut être un GroupBox ou un Panel.
GroupBox Panel avec AutoScroll=True et BorderStyle=Single
Pour l'utilisateur, le fait que toutes les options soient regroupées dans un panneau est un indice visuel logique (Tous les RadioButton permettrons un choix dans une même catégorie de données).
Au moment de la conception, tous les contrôles peuvent être déplacés facilement, si vous déplacez le contrôle GroupBox ou Panel, tous les contrôles qu'il contient sont également déplacés. Les contrôles regroupés dans un panneau ou un GroupBox sont accessibles au moyen de la propriété Controls du panneau.
Le contrôle Panel est similaire au contrôle GroupBox, mais seul le contrôle Panel peut disposer de barres de défilement et seul le contrôle GroupBox peut afficher une légende. La légende de la GroupBox est définie par la propriété Text.
Pour faire apparaître les barres de défilement dans le Pannel mettre AutoScroll =True et AutoScrollMinSize =100;100
Dans un Panel, pour afficher des barres de défilement, attribuez à la propriété AutoScroll la valeur true.. La propriété BorderStyle détermine si la zone est entourée d'une bordure invisible (None), d'une simple ligne (FixedSingle) ou d'une ligne ombrée (Fixed3D).
Comment créer un contrôle Panel ?
Faites glisser un contrôle Panel de l'onglet Windows Forms de la boîte à outils jusqu'à un formulaire.
Ajoutez des contrôles au panneau en les déposant dans le panneau.
Si vous voulez mettre dans le panneau des contrôles existants, sélectionnez-les tous, coupez- les dans le Presse-papiers, sélectionnez le contrôle Panel et collez-les.
Le contrôle PictureBox peut afficher une image mais peu aussi servir de conteneur à d'autres contrôles.
Retenons la notion de conteneur qui est le contrôle parent.
Ce contrôle permet de créer des onglets comme dans un classeur, onglets entièrement gérés par VB. Chaque page peut contenir d'autres contrôles.
En mode conception, en passant par la propriété TabPages, on ajoute des onglets dont la propriété Text contient le texte à afficher en haut (Ici : Page 1..). il suffit ensuite de cliquer sur chaque onglet et d'y ajouter les contrôles.
En mode run les onglets fonctionnent automatiquement: cliquez sur Page 2 affiche la page correspondante (et déclenche l'événement Click de cet objet TabPage)…
La propriété Alignment permet de mettre les onglets en haut, en bas, à droite, à gauche.
Exemple : 3 cases à cocher permettent de colorer un label en vert rouge ou bleu.
Comment gérer les évènements ?
On peut écrire 3 routines complètes pour chaque case à cocher.
Il est aussi toujours possible dans chacune des 3 procédures CouleurX.checkedChanged de vérifier si la case est cochée et de modifier la couleur.
C'est plus élégant d'avoir une procédure unique qui, en fonction de la case à cocher qui a déclenché l'évènement, change la couleur.
On désire donc parfois que l'évènement de plusieurs contrôles différents soit dirigé sur une seule et même procédure. Mais, la notion de groupe de contrôle comme en VB6 n'existe plus!!!
Par contre par l'intermédiaire du Handles, il est possible d'associer plusieurs évènements à une seule procédure :
Private Sub CouleurCheckedChanges (ByVal sender As System.Objet, ByVal e As System.EventArgs)
End Sub
Cette procédure est activée quand les cases à cocher CouleurVert CouleurBleu, CouleurRouge changent d'état.
A noter que Sender est le contrôle ayant déclenché l'évènement et e l'évènement correspondant.
Pour modifier la couleur il faut ajouter dans la procédure :
Select Case Case "CouleurRouge"
Lbl.BackColor= ..Rouge
..
Je ne suis pas certain que cela fonctionne, il faut plutôt mettre :
Select Case sender
Case CouleurRouge
Enfin la ligne suivante marche !
If sender Is CouleurRouge Then
On peut :
- Dimensionner les contrôles - Les positionner.
Tous les contrôles héritent donc tous de la classe Windows Forms. Les Windows Forms ont des propriétés, que tous les contrôles récupèrent :
Concernant la taille :
On peut utiliser :
- Left, Top coordonnées du coin supérieur droit et Bottom, Right inférieur gauche.
- Location : coordonnées X, Y du coin supérieur droit du contrôle en pixels.
- Height, Width pour la hauteur et la largeur du contrôle en pixels. - Size : hauteur, largeur peut aussi être utilisé.
Exemple :
=188
=300
Ou
Button.Location= New System.Drawing.Point(188,300)
System.Drawing.Point() positionne un point dans l’espace.
En mode conception il est bien plus simple de dimensionner les contrôles à la main dans la fenêtre Design.
Pour le redimensionnement de fenêtre :
Pour que l’utilisateur puisse redimensionner la fenêtre qu’il a sous les yeux (en cliquant sur les bords) il faut que la propriété FormBorderStyle de la fenêtre = Sizable.
Mais si l’utilisateur modifie la taille de la fenêtre qui contient les contrôles, la taille des contrôles ne suit pas.
(Avant cette version , il fallait dans l’événement Form_Resize, déclenché par la modification des dimensions de la fenêtre, écrire du code modifiant les dimensions et positions des contrôles afin qu’il s’adaptent à la nouvelle fenêtre.)
En c’est plus simple grâce à :
Anchor :
Permet d’ancrer les bords.
Un bord ancré reste à égale distance du bord du conteneur quand le conteneur (la fenêtre) est redimensionné.
En mode conception il suffit de cliquer sur '. . .' en face de Anchor pour voir s’ouvrir une fenêtre, cliquer sur les bords que vous voulez ancrer. Par défaut les bord Top (haut) et left(gauche) sont ancrés.
Expliquons :
Left est ancré, si je déplace le bord droit de la fenêtre, le contrôle n’est pas déplacé car la distance bord gauche de la fenêtre et bord gauche du contrôle est fixe. Par contre si je déplace le bord gauche de la fenêtre, le contrôle suit.
Exemple :
Prenons 2 contrôles dans une fenêtre, celui de gauche avec Anchor à left et celui de droite à left et right.
Si je déplace le bord droit (ou le gauche d’ailleurs) : le contrôle droit est redimensionné, les 2 contrôles restent cote à cote.
Amarre aux bords. Il y a même possibilité d’amarrer aux 4 bords (Fill) pour remplir le conteneur, et de modifier la propriété DockPaddind afin se s’éloigner légèrement des bords pour faire joli.
Le contrôle Splitter servent à redimensionner des contrôles au moment de l'exécution. Le contrôle Splitter est utilisé dans les applications dont les contrôles présentent des données de longueurs variables, comme l'Explorateur Windows.
Pour permettre à un utilisateur de redimensionner un contrôle ancré au moment de l'exécution, ancrez le contrôle à redimensionner au bord d'un conteneur, puis ancrez un contrôle Splitter sur le même côté de ce conteneur.
MainMenu :
On peut ajouter un menu dans une fenêtre. Beaucoup d’applications contiennent un menu.
Exemple de menu :
Fichier
Ouvrir
Fermer
Imprimer
Quitter
Edition
Couper
Copier
Coller
On remarque que le contenu des menus est standardisé afin que l’utilisateur s’y retrouve sans aide (L’utilisateur lit, à mon avis, rarement les aides !!!)
Comment créer un menu ?
En allant dans la boite à outils, chercher un main menu et en le déposant sur la fenêtre : il apparaît en dessous de la fenêtre.
Pour ‘dessiner’ le menu, il suffit de mettre le curseur sur le menu en haut de la fenêtre, ou est écrit ‘Taper ici’, à cet endroit tapez le texte du menu, ‘Fichier’ par exemple.
Il apparaît automatiquement un ‘Tapez Ici‘ pour les lignes dessous ou le menu suivant. Les lignes du menu sont nommées automatiquement MenuItem1, MenuItem2…
Quand le curseur est sur une ligne du menu, la fenêtre de propriété donne les propriétés de la ligne :
La propriété ShortKey permet de créer un raccourci.
La propriété Checked permet de cochez la ligne La propriété Visible permet de faire apparaître ou non une ligne.
Si vous double-cliquez sur la ligne du menu vous voyez apparaître :
Private Sub MenuItem1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem1.Click
End Sub C’est la procédure événement liée à la ligne du menu.
Quand l’utilisateur clique sur une ligne du menu c’est le code contenu dans cette procédure qui est effectué.
ContextMenu :
C'est un menu qui s'ouvre quand, sur un objet, on clique sur le bouton droit de la souris.
En allant dans la boite à outils, chercher un Context menu, on le dépose sur la fenêtre, il apparaît en dessous de la fenêtre.
Si on le sélectionne avec la souris, il apparaît en haut et comme pour le menu principal, on peut ajouter des lignes.
Il faut ensuite affecter ce Context Menu à un contrôle, pour cela donner à la propriété ContextMenu du contrôle le nom du ContextMenu.
TextBox1.ContextMenu = ContextMenu1
Si vous double-cliquez sur une ligne du menu vous voyez apparaître les procédures évènement correspondantes.
Nous allons étudier comment un objet de l'interface devient actif.
Lorsqu'une fenêtre ou un contrôle est actif on dit qu'il a le focus.
Si une fenêtre prend le focus, sa barre de titre en haut prend la couleur active, si c'est un contrôle texte, le curseur apparaît dedans.
Comment donner le focus à une fenêtre ?
Si une fenêtre est visible la méthode Activate lui donne le focus.
Form1.Activate()
Dans ce cas l'évènement Form1_Activated survient.
La méthode Desactivate est déclenchée quand la fenêtre perd le focus.
Comment donner le focus à un contrôle ?
Avec la méthode Focus TxtNom.Focus()
Avec la méthode Select : TxtNom.Select() 'donne le focus à la zone de texte Txnom et met le curseur dedans.
On peut la surcharger et en plus sélectionner une portion du texte :
TxtNom.Select(2,3) 'donne le focus et sélectionne 3 caractères à partir du second. Ou forcer à ne rien sélectionner (second argument à 0). On peut interdire à un contrôle le focus en donnant la valeur False à sa propriété CanFocus.
Aussi avant de donner le focus il est préférable de vérifier s'il peut le prendre :
If TxtNom.CanFocus then
TxtNom.Focus()
End If
L'évènement GotFocus se produit quand le contrôle prend le focus. Private Sub TxtNom_GotFocus..
End Sub
Enter Se produit quand l'utilisateur entre dans le contrôle.
GotFocus Se produit quand le contrôle prend le focus.
Leave Se produit quand le focus quitte le contrôle.
Validating
Se produit lorsque le contrôle est en cours de validation. La validation c'est vous qui devez la faire!!!
Pour un bouton par exemple se produit lorsque l'on quitte le bouton, cela permet de contrôler la validité de certaines données et si nécessaire d'interdire de quitter le contrôle si certaines conditions ne sont pas remplies :
Private Sub Button1_Validating ((ByVal sender As Object, ByVal e As
System.ComponentModel.CancelEventArgs) Handles Button1.Validating
If condition then
e.Cancel = True 'Annuler la perte du focus
End If End Sub
Validated
Se produit lorsque le contrôle à terminé sa validation
LostFocus L'évènement LostFocus se produit quand le contrôle perd le focus.
Si la propriété CauseValidating du contrôle a la valeur false, les événements Validating et Validated sont supprimés.
Les événements Enter et Leave sont supprimés dans les formulaires (fenêtres). Les événements équivalents dans la classe Form sont les événements Activated et Desactivate.
Certains contrôles ne peuvent pas avoir le focus, comme les labels par exemple.
Dans une application ou un utilisateur saisi beaucoup de données dans de multiples contrôles, il passe souvent d'un contrôle (TextBox par exemple) au suivant avec la touche TAB.
|
| |
Comment permettre cela ?
Chaque contrôle à une propriété TabIndex qui s'incrémente automatiquement de 0 à 1, 2, 3 quand on ajoute des contrôles sur une fenêtre.
Lorsque l'utilisateur appuie sur TAB, le focus passe au contrôle qui a le TabIndex immédiatement supérieur. On peut modifier le TabIndex des contrôles pour modifier l'ordre de tabulation.
Quand TabStop a la propriété False (au niveau d'un contrôle) celui ci est exclu de l'ordre de tabulation et le focus ne s'arrête pas.
Dans beaucoup d'applications certains contrôles ont un raccourci clavier :
Exemple : Nouveau est une ligne de menu. N étant souligné, ALT-N déclenche la ligne de menu, donne le focus au contrôle.
Comment faire cela :
Dans la propriété Text du contrôle, quand on tape le texte en mode conception, il faut mettre un '&' avant la lettre qui servira de raccourci clavier.
'&Nouveau' dans notre exemple donnera bien Nouveau et ALT N fonctionnera.
Pour une TextBox, la propriété text ne peut pas être utilisée, aussi il faut mettre devant la textBox un contrôle label (qui lui ne peut pas avoir le focus), si le TabIndex du label et du TextBox se suivent, le fait de faire le raccourci clavier du label donnera le focus au TextBox.
Nom
|
Exemple quand l'utilisateur tapera Alt-N, le focus ira dans le TextBox dessous.
Comment mettre une barre de bouton en haut et une barre d'état en bas?
Voici un exemple classique, sous le menu il y a une barre de bouton: Nouveau, Ouvrir, Enregistrer, Chercher, Imprimer
Aller chercher dans la boite à outils un contrôle ToolBar, il se place en haut, sous le menu. Mettre aussi un ImageList. (Un contrôle ImageList est un contrôle qui stocke des images, chaque image étant chargés en mode conception et repérées par un numéro (0, 1, 2, 3 )
Dans les propriétés du ToolBar mettre dans la propriété ImageList le nom du contrôle ImageList qui contient les images des boutons.
Ouvrir la collection Buttons dans la fenêtre des propriétés de la ToolBar pour pouvoir ajouter ou modifier les boutons :
Vous pouvez ajouter ou enlever des boutons.
Chaque bouton a ses propriétés affichées à droite :
- Name Nom du Bouton. Exemple : NewButton.
- ImageIndex donne le numéro de l'image (contenue dans l'imagelist) qui doit s'afficher dans le bouton.
- ToolTipText donne le texte du ToolTip (Carré d'aide qui apparaît quand on est sur le bouton) Il faut aussi que la propriété ShowToolTip de la ToolBar soit à True
L'évènement déclenché par le click de l'utilisateur sur un bouton est :
ToolBar1_ButtonClick
L'argument e contient les arguments de l'évènement click de la ToolBar. e.Button contient le nom du bouton qui a déclenché l'évènement. Pour chaque nom de bouton on appellera la procédure correspondante: NewDoc(), Open()
Comme d'habitude il suffit de double-cliquer sur la ToolBar pour faire apparaître
ToolBar1_ButtonClick
Voici le code complet :
Private Sub ToolBar1_ButtonClick(ByVal Sender As System.Object, ByVal e As
System.Windows.Forms.ToolBarButtonClickEventArgs) Handles toolBar1.ButtonClick If e.Button Is NewButton Then
NewDoc()
ElseIf e.Button Is OpenButton Then Open()
ElseIf e.Button Is SaveButton Then
Save()
ElseIf e.Button Is PreviewButton Then
PrintPreview()
End If
End Sub
La barre d'état se trouve en bas de la fenêtre et affiche des informations relatives aux opérations en cours.
Dans la fenêtre des propriétés du StatusBar, la collection Panels contient les zones d'affichage du StatusBar.
Dans le code, pour modifier le texte d'une zone faire : StatusBar1.Panels(0).Text="1715.2F"
Comment afficher des images ?
Le contrôle PictureBox sert à afficher des graphismes au format bitmap, GIF, JPEG, métafichier ou icône (Extension .BMP .GIF .JPG .WMF .ICO)
L'image affichée est déterminée par la propriété Image, laquelle peut être définie au moment de l'exécution ou du design. La propriété SizeMode détermine la façon dont l'image et le contrôle se dimensionnent l'un par rapport à l'autre.
On peut charger une image en mode conception ou dans le code :
PictureBox1.Image = Image.FromFile(")
(L'objet de la Classe Image charge une image d'un fichier puis l'affecte à la propriété Image.) ou par PictureBox1.Image.FromFile("") cette syntaxe ne marche pas!!!Pourquoi?
Ho! Merveille, les GIF animés sont acceptées et s'animent sous VB.
Comment effacer une image?
If Not (PictureBox1.Image Is Nothing) Then
PictureBox1.Image.Dispose()
PictureBox1.Image = Nothing
End If Les objets de la Classe Image ont comme d'habitude des propriétés et des méthodes.
La méthode RotateFlip permet par exemple d'effectuer une rotation de l'image, quand on tape le code, VB donne automatiquement la liste des paramètres possible.
PictureBox1.Image.RotateFlip(RotateFlipType.Rotate90FlipX)
La méthode Save sauvegarde l'image dans un fichier.
("c:\") Noter bien que le nom de l'extension suffit à imposer le format de l'image.
On peut charger une image .GIF puis la sauvegarder en .BMP
Il y a bien d'autres propriétés gérant les dimensions, la palette de l'image.
La propriété ‘Image’ des contrôles :
De nombreux contrôles Windows Forms peuvent afficher des images. L'image affichée peut être une icône symbolisant la fonction du contrôle ou une image ; par exemple, l'image d'une disquette sur un bouton indique généralement une commande d'enregistrement. L'icône peut également être une image d'arrière-plan conférant au contrôle une certaine apparence. Pour tous les contrôles affichant des images, l'image peut être définie à l'aide des propriétés Image ou BackgroundImage.
Pour affecter à la propriété Image ou BackgroundImage un objet de type
System.Drawing.Image en général, vous utiliserez la méthode FromFile de la classe Image pour charger une Image à partir d'un fichier.
Exemple pour un bouton:
button1.Image = Image.FromFile("C:\Graphics\") ' Aligne l'image.
button1.ImageAlign = ContentAlignment.MiddleRight
Exemple pour un label:
Dim Label1 As New Label() Dim Image1 As Image
Image1 = Image.FromFile("c:\\") ' modifier la taille du label pour qu'il affiche l'image.
= ' Mettre l'image dans le label.
Label1.Image = Image1
Si on renseigne la propriété Image, on ne peut pas utiliser en même temps la propriété ImageList décrite ci-dessous.
Il sert de containeur à image, c'est une collection d'images. les images qu'il contient seront utilisées par d'autres contrôles (PictureBox, Listview, TreeView, Button .)
Il n'est pas visible en exécution.
En conception il apparaît en bas sous la fenêtre. A droite figurent ses propriétés, en particulier, la collection Images qui contient les images et la propriété TransparentColor qui indique la couleur qui doit être transparent, c'est à dire non visible.
Si je clique sur le bouton en face de Images, l'éditeur de collections d'image s'ouvre.
On peut ajouter des images avec le bouton 'Ajouter'. L'ImageList est ainsi chargée.
Ensuite pour utiliser une image de l'ImageList dans un autre contrôle, il faut modifier les propriétés de cet autre contrôle (un bouton par exemple).
La propriété ImageList du bouton doit contenir le nom du contrôle imageList et ImageIndex du bouton doit contenir l'index de l'image dans l'imageList.
btOk.ImageList = imagelist1 btOk.ImageIndex = 2
Un ImageList peut aussi être chargée par code :
(Image.FromFile(NomImage)) On ajoute à la collection Images une image venant d'un fichier nommé NomImage.
On peut surchargé la méthode Add en fournissant en plus la couleur transparente.
(Image.FromFile(imageToLoad), CouleurTransparente)
La taille des images peut aussi être modifiée par code :
imageList1.ImageSize = New Size(255, 255) imageList1.TransparentColor = Color.White
Résumons
Révision pour y voir plus clair
3.30 Calcul de l’IMC, Révision++ Structuration des programmes
Ce chapitre permet de 'réviser' pas mal de notions.
Qu’est ce que l’IMC ?
L'index de masse corporelle est très utilisé par les médecins. Il est calculé à partir du poids et de la taille :
IMC=Poids/Taille au carré (avec Poids en Kg, Taille en mètres)
Cela permet de savoir si le sujet est : - maigre (IMC<18.5)
- normal (IMC idéal=22) - en surpoids (IMC>25) - obèse (IMC>30).
On peut calculer le poids idéal par exemple PI= 22* T*T Nous allons détailler ce petit programme :
Quel est le cahier des charges du programme ?
L'utilisateur doit pouvoir :
Saisir un poids, une taille, cliquer sur un bouton 'Calculer'
Les routines doivent : Vérifier que l'utilisateur ne fait pas n'importe quoi.
Calculer et afficher les résultats : l'IMC mais aussi, en fonction de la taille, le poids idéal, les poids limites de maigreur, surpoids, obésité.
Il faut 2 zones de saisie pour saisir le poids et la taille :
On crée 2 'TextBox' que l'on nomme :
- TexBoxPoids - TextBoxTaille (On laisse la propriété Multiline à False ) pour n'avoir qu'une zone de saisie.
Pour afficher les résultats, on crée 5 'label' que l'on met les uns sous les autres. (Pour aller plus vite et que les labels fassent la même taille, on en crée un puis par un copier et des coller, on crée les autres) :
- labelImc 'pour afficher l'Imc
- labelPi 'pour afficher le poids idéal
- labelM 'pour afficher le poids limite de la maigreur. - labelS 'pour afficher le poids limite du surpoids - labelO 'pour afficher le poids limite de l'obésité.
Ensuite on ajoute des labels devant et derrière chaque TextBox et label pour indiquer devant, ce qu'ils contiennent et derrière, l'unité.
On ajoute 2 boutons :
- ButtonCalcul - ButtonQuitter
Cela donne :
Pour faire beau :
La propriété Text de la fenêtre contient "Calcul IMC", pour afficher cela dans la barre de titre.
La propriété ForeColor de labelImc est en rouge.
La propriété BorderStyle des labels a la valeur 'Fixed3d' ce qui rend les bords visibles.
La procédure évènement Form1_Load qui s'effectue lorsque la fenêtre se charge initialise les zones d'affichage en les vidant :
Private Sub Form1_Load(..) = "" = ""
= ""
= ""
= ""
= ""
= "" End Sub
La procédure ButtonCalcul_Click qui se déclenche lorsque l'utilisateur clique sur le bouton 'Calculer' contient le code principal.
Voici la totalité du code, on le détaillera dessous.
Private Sub ButtonCalcul_Click(..)
Dim sPoids As Single 'Variable Single contenant le poids
Dim sTaille As Single 'Variable Single contenant la taille
'******Controle de validité des entrées************
'Les valeurs saisies sont-elles numérique?
If Not (IsNumeric()) Then
MsgBox("Entrez une valeur numérique pour la taille") Exit Sub
End If
If Not (IsNumeric()) Then
MsgBox("Entrez une valeur numérique pour le poids") Exit Sub
End If
'Convertir les textes saisies en single ' et les mettre dans les variables sTaille = CType(, Single) / 100 sPoids = CType(, Single)
'Les valeurs saisies sont-elles cohérentes?
If sTaille < 50 Or sTaille > 250 Then MsgBox("Entrez une taille valide") Exit Sub
End If
If sPoids < 20 Or sPoids > 200 Then
MsgBox("Entrez un poids valide")
Exit Sub End If
'Effectuer les calculs et afficher les résultats.
= (Math.Round(sPoids / (sTaille * sTaille), 2)).ToString
= (Math.Round(22 * (sTaille * sTaille), 2)).ToString
= (Math.Round(18.5 * (sTaille * sTaille), 2)).ToString
= (Math.Round(25 * (sTaille * sTaille), 2)).ToString
= (Math.Round(30 * (sTaille * sTaille), 2)).ToString
End Sub Détaillons :
Quelles sont les différentes étapes ?
- On déclare les variables.
- On vérifie que ce qui a été tapé est numérique.
- On convertit le texte qui est dans la TextBox en Single - On teste si les valeurs de poids et taille sont cohérentes. - On fait le calcul et on affiche.
Déclaration de variables.
Dim sPoids As Single 'Variable Single contenant le poids Dim sTaille As Single 'Variable Single contenant la taille Ce sont des variables 'privées' propres à la procédure (utilisation de Dim ou Private).
Contrôle de validité :
L'utilisateur est sensé avoir tapé un poids et une taille puis cliqué sur le bouton 'Calculer'. Mais il ne faut absolument pas lui faire confiance : il a peut-être oublié de taper le poids ou a donner une taille=0 (l'ordinateur n'aime pas diviser par 0!!), il a peut-être fait une faute de frappe et tapé du texte!!
Donc il faut tester ce qui a été tapé, s'il y a erreur, on prévient l'utilisateur avec une 'MessageBox' puis on sort de la routine par (Exit Sub) sans effectuer de calculs.
Ici par exemple, on teste si le texte saisi dans la zone taille n'est pas numérique :
If Not (IsNumeric()) Then
MsgBox("Entrez une valeur numérique pour la taille") Exit Sub
End If
Amélioration : On aurait pu automatiquement effacer la valeur erronée et placer le curseur dans la zone à ressaisir :
If Not (IsNumeric()) Then
MsgBox("Entrez une valeur numérique pour la taille")
Exit Sub
End If
Conversion :
Si le texte est bien 'Numéric', on fait la conversion en réel simple précision (Single) sTaille = CType(, Single) / 100
On utilise CType pour convertir une String en Single.
On divise taille par 100 car l'utilisateur à saisie la taille en centimètres et les formules nécessite une taille en mètres.
Problème du séparateur décimal dans les saisies.
Pourquoi saisir la taille en Cm? C’est pour éviter d'avoir à gérer le problème du séparateur décimal si la taille est saisie en mètres: L'utilisateur va t-il taper "1.75" ou "1,75" si je lui demande des mètres. On rappelle que pour convertir un texte en Single VB accepte le point et pas la virgule.
Pour ma part voici ma solution : si je demandais des mètres j'ajouterais en début de routine une instruction transformant les ',' en '.' :
= Replace(, ",", ".")
Faire les calculs et afficher les résultats.
Je fais le calcul:
sPoids / (sTaille * sTaille)
J'arrondis à 2 décimales après la virgule grâce à Math.Round( ,2):
Math.Round(sPoids / (sTaille * sTaille), 2)
Je convertis en String:
(Math.Round(sPoids / (sTaille * sTaille), 2)).ToString
J'affiche dans le label 'labelImc':
= (Math.Round(sPoids / (sTaille * sTaille), 2)).ToString
(J'aurais pu aussi ne pas arrondir le calcul mais formater l'affichage pour que 2 décimales soient affichées)
La procédure ButtonQuitter_Click déclenchée quand l'utilisateur clique sur le bouton 'Quitter' ferme la seule fenêtre du projet (c'est Me , celle ou on se trouve), ce qui arrête le programme. Private Sub ButtonQuitter_Click() Me.Close() End Sub
Ici on a fait simple : une procédure évènement calcul et affiche les résultats. On aurait pu, dans un but didactique 'structurer' le programme.
On aurait pu découper le programme en procédure :
- Une procédure faisant le calcul. - Une procédure affichant les résultats.
Pour les variables il y a dans ce cas 2 possibilités :
- Mettre les variables en 'Public' dans un module Standard. - Utiliser des variables privées et les passer en paramètres.
Première solution : Variables ‘Public’
Créer dans un module standard des variables Public pour stocker les variables Poids et Taille, résultats (Public sIMC A Single par exemple), créer dans ce même module standard une procédure Public nommée 'Calculer' qui fait les calculs et met les résultats dans les variables public, enfin dans le module de formulaire créer une procédure 'AfficheResultat' affichant les résultats.
Module standard :
'Déclaration de variables Public
Public sPoids As Single Public sTaille As Single
Public sIMC A Single
..
'Procedure Public de calcul
Public Sub Calculer sIMC=Math.Round(sPoids / (sTaille * sTaille), 2)
End Sub
Module de formulaire Form1 :
'Procédure évènement qui appelle les divers routines
Private Sub ButtonCalculer_Click
sTaille = CType(, Single) / 100 Calculer() 'Appelle la routine de calcul
AfficheResultat() 'Appelle la routine d'affichage
End Sub
'routine d'affichage
Private Sub AfficheResultat()
= sIMC.ToString
End Sub
On voit bien que la routine de Calcul est générale et donc mise dans un module standard et d'accès 'Public', alors que la routine d'affichage affichant sur Form1 est privée et dans le module du formulaire.
Seconde solution : Variables ‘Privées’ et passage de paramètres
On aurait pu ne pas créer de variables 'public' mais créer des fonctions (CalculIMC par exemple) à qui on enverrait en paramètre le poids et la taille et qui retournerait le résultat du calcul. Une procédure AfficheResultatIMC recevrait en paramètres la valeur de l'IMC à afficher. Module standard :
'Pas de déclaration de variables Public
..
'Function Public de calcul: reçoit en paramètre le poids et la taille 'retourne l'Imc
Public Function CalculerIMC (T as Single, P As Single) As Single Return Math.Round(P / (T*T), 2)
End Sub
Module de formulaire Form1 :
'Procédure évènement qui appelle les divers routines
Private Sub ButtonCalculer_Click
sTaille = CType(, Single) / 100
'Appelle de la routine calcul avec l'envoie de paramètres sPoids et sTaille 'Au retour on a la valeur de L'imc que l'on envoie à la routine d'affichage.
AfficheResultatIMC(CalculerIMC(sTaille, sPoids)) 'Appelle la routine d'affichage End Sub
'routine d'affichage
Private Sub AfficheResultatIMC(I As Single) = i.ToString
End Sub
Remarque :
La ligne AfficheResultatIMC(CalculerIMC(sTaille, sPoids)) est équivalente à : Dim s As single s=(CalculerIMC(sTaille, sPoids) AfficheResultatIMC(s))
mais on se passe d'une variable temporaire.
Conclusion : Faut-il travailler avec des variables Public ou passer des paramètres ?
Réponses : A mon avis, les 2 et "ça dépend"!!!(Bien la réponse).
Et votre avis ?
Dans quel ordre écrire dans un module.
Le code Visual Basic est stocké dans des modules (modules de formulaires, module de classe ), chaque module est dans un fichier ayant l'extension '.vb". Les projets sont composés de fichiers, lesquels sont compilés pour créer des applications.
Respecter l'ordre suivant :
1. Instructions Option toujours en premier (force des contraintes de déclaration de variables, de conversion de variables, de comparaison).
2. Instructions Imports (charge des espaces de noms)
3. Procédure Main (la procédure de démarrage si nécessaire)
4. Instructions Class, Module et Namespace, le cas échéant
Exemple :
Option Explicit On
Imports System.AppDomain
Imports Microsoft.VisualBasic.Conversion
Inherits
Dim WithEvents m As PrintDocument1
#Region " Code généré par le Concepteur Windows Form "
Public d As Integer
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles End Sub Dim A As integer
On remarque de nouveau l'importance de l'endroit ou les variables sont déclarées : Dans notre exemple A est accessible uniquement dans Form_Load, alors que d est public.
Si vous entrez les instructions dans un ordre différent, vous risquez de créer des erreurs de compilation.
Exemple de petits programmes
E 3.1 Exemples : Conversion Francs/EurosComment créer un programme de conversion Francs=>Euros et Euros=> Francs ?
Euros
2
Francs:
13.12
Il y a une zone de saisie Euros, une zone Francs, si je tape dans la zone Euros '2' il s'affiche '13.12' dans la zone Francs, cela fonctionne aussi dans le sens Francs=>Euros.
Comment faire cela?
Un formulaire affichera les zones de saisie, un module standard contiendra les procédures de conversion.
On crée un formulaire contenant :
- 2 TextBox BoiteF et BoiteE, leurs propriétés Text=""
- 2 labels dont la propriété Text sera ="Euros" et "Francs", on les positionnera comme ci-dessus.
Dans le formulaire, je dimensionne un flag (ou drapeau) : flagAffiche, il sera donc visible dans la totalité du formulaire. Je l'initialise à True. Public Class Form1
Inherits Dim flagAffiche As Boolean = True
Comme la conversion doit se déclencher automatiquement lorsque le texte de BoiteF ou BoiteE change, j'utilise les évènements 'TextChanged' de ces TextBox.
Pour la conversion Euros=>Francs, dans la procédure TextChanged de BoiteE, je récupère le texte tapé (), j'appelle la fonction ConversionEF en lui envoyant comme paramètre ce texte.
La fonction me retourne un double que je transforme en string et que j'affiche dans l'autre TextBox(BoiteF).
Private Sub BoiteE_TextChanged(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles BoiteE.TextChanged If flagAffiche = True Then flagAffiche = False
= (ConversionEF()).ToString flagAffiche = True
End If End Sub
Idem pour l'autre TextBox :
Private Sub BoiteF_TextChanged(ByVal sender As Object, ByVal e As
System.EventArgs) Handles BoiteF.TextChanged If flagAffiche = True Then flagAffiche = False
= (ConversionFE()).ToString flagAffiche = True
End If
End Sub
End Class
A quoi sert le flag : flagAffiche?
A éviter une boucle sans fin, sans flag, BoiteF_TextChanged modifie BoiteE_Text qui déclenche BoiteE_TextChanged qui modifie BoiteF_Text qui déclenche BoiteF_TextChanged Avec le flag, quand je vais modifier la propriété Text d'une TextBox, le met le flag à False, cela indique à l'autre évènement TextChanged de ne pas lui aussi convertir et afficher.
Enfin il faut écrire les procédures qui font la conversion : ConversionEF et ConversionFE dans un module standard. Ces procédures 'Function' appellent elles mêmes une autre fonction qui arrondi les résultats à 2 décimales. Pour transformer des Euros en Francs, je les multiplie par 6.55957 puis j'arrondis.
On remarque que ces procédures reçoivent une string en paramètres et retourne un double.
Module Module1
Public Function ConversionEF(ByVal e As String) As Double
Dim somme As Double Dim resultat As Double somme = Val(e) resultat = Arrondir(somme * 6.55957)
Return resultat End Function
Public Function ConversionFE(ByVal e As String) As Double
Dim somme As Double Dim resultat As Double somme = Val(e) resultat = Arrondir(somme / 6.55957)
Return resultat End Function
Enfin la Function Arrondir arrondit à 2 décimales: pour cela on multiplie par 100, on arrondit à l'entier avec Round puis on divise par 100.
Public Function Arrondir(ByVal Valeur As Double) As Double
'arrondi a 2 chiffres après la virgule
Return (Math.Round(Valeur * 100)) / 100
End Function End Module
A noter que l'on aurait pu utiliser une surcharge de Round qui arrondit directement à 2 décimales :
Return (Math.Round(Valeur, 2))
Exercice:
Quel code mettre dans la procédure Button_Click d'un bouton nommé 'Remise à zéro' qui met les 2 zones de saisie à zéro ?
(Pensez au flag)
E 3.2 Exemple : Mensualités d’un prêtComment créer un programme qui calcul les mensualités d'un prêt ?
Dans l'espace Microsoft.VisualBasic il existe des fonctions financières.
Pmt calcul les mensualités d'un prêt.
Remboursement mensuel= Pmt( Rate, NPer, PV, FV, Due)
|
Rate |
Obligatoire. Donnée de type Double indiquant le taux d'intérêt par période. Si taux d'intérêt annuel de 10 pour cent et si vous effectuez des remboursements mensuels, le taux par échéance est de 0,1/12, soit 0,0083. |
|
NPer PV FV |
Obligatoire. Donnée de type Double indiquant le nombre total d'échéances. Par exemple, si vous effectuez des remboursements mensuels dans le cadre d'un emprunt de quatre ans, il y a 4 * 12 (soit 48) échéances. Obligatoire. Double indiquant la valeur actuelle. Par exemple, lorsque vous empruntez de l'argent pour acheter une voiture, le montant du prêt correspond à la valeur actuelle (pour un emprunts il est négatif). Facultatif. Double indiquant la valeur future ou le solde en liquide souhaité au terme du dernier remboursement. Par exemple, la valeur future d'un emprunt est de 0 F car il s'agit de sa valeur après le dernier remboursement. Par contre, si vous souhaitez économiser 70 000 F sur 15 ans, ce montant constitue la valeur future. Si cet argument est omis, 0 est utilisée par défaut. |
|
Due |
Facultatif. Objet de type Microsoft.VisualBasic.DueDate indiquant la date d'échéance des paiements. Cet argument doit être DueDate.EndOfPeriod si les paiements sont dus à terme échu ou DueDate.BegOfPeriod si les paiements sont dus à terme à échoir (remboursement en début de mois). Si cet argument est omis, DueDate.EndOfPeriod est utilisé par défaut. |
Notez que si Rate est par mois NPer doit être en mois, si Rate est en année NPer doit être en année.
Sub CalculPret()
Dim PVal, Taux, FVal, Mensualite, NPerVal As Double
Dim PayType As DueDate
Dim Response As MsgBoxResult
Dim Fmt As String
Fmt = "###,###,##0.00" ' format d'affichage.
FVal = 0 '0 pour un prêt.
PVal = CDbl(InputBox("Combien voulez-vous emprunter?")) Taux = CDbl(InputBox("Quel est le taux d'intérêt annuel?"))
If Taux > 1 Then Taux = Taux / 100 ' Si l'utilisateur à tapé 4 transformer en 0.04.
NPerVal =12* CDbl(InputBox("Durée du prêt (en années)?"))
Response = MsgBox("Echéance en fin de mois?", MsgBoxStyle.YesNo)
If Response = Then
PayType = DueDate.BegOfPeriod
Else
PayType = DueDate.EndOfPeriod
End If
Mensualite = Pmt(Taux / 12, NPerVal, -PVal, FVal, PayType)
MsgBox("Vos mensualités seront de " & Format(Mensualite, Fmt) & " par mois")
End Sub IPmt calcul les intérêts pour une période.
Calculons le total des intérêts :
Dim IntPmt, Total, P As Double For P = 1 To TotPmts ' Total all interest.
IntPmt = IPmt(APR / 12, P, NPerVal, -PVal, Fval, PayType)
Total = Total + IntPmt
Next Period
Ce qu’il faut savoir pour faire un vrai
programme
Quand vous démarrez votre programme, quelle partie du code va être exécutée en premier ?
Vous pouvez le déterminer en cliquant sur le menu Projet puis Propriétés de NomduProjet, une fenêtre Page de propriétés du projet s'ouvre.
Sous la rubrique Objet du démarrage, il y a une zone de saisie avec liste déroulante permettant de choisir :
- Le nom d'une fenêtre du projet ou - Sub Main()
Si vous tapez le nom d'une fenêtre du projet, c'est celle-ci qui démarre : cette fenêtre est chargée au lancement du programme et la procédure Form_Load de cette fenêtre est effectuée.
C'est cette procédure Sub Main qui s'exécute en premier lorsque le programme est lancé.
Dans ce cas, il faut ajouter dans un module (standard ou d'une feuille) une Sub nommé Main(),
Exemple :
En mode conception Form1 a été dessinée, C'est le modèle 'la Classe' de la fenêtre qui doit s'ouvrir au démarrage.
Dans Sub Main(), on crée une fenêtre de départ que l'on nomme initForm avec le moule, la Class Form1 en ‘instancant’ la nouvelle fenêtre.
Public Shared Sub Main()
Dim initForm As New Form1 initForm.ShowDialog() End Sub
Fenêtre Splash Dans la Sub Main il est possible de gérer une fenêtre Splash.
C'est une fenêtre qui s'ouvre au démarrage d'un programme, qui montre simplement une belle image, pendant ce temps le programme initialise des données, ouvre des fichiers ensuite la fenêtre 'Splash' disparaît et la fenêtre principale apparaît.
Exemple :
Je dessine Form1 qui est la fenêtre Spash.
Dans Form2 qui est la fenêtre principale, j'ajoute :
Public Shared Sub Main()
Dim FrmSplash As New Form1 'instance la fenêtre Splash Dim FrmPrincipal As New Form2 'instance la feuille principale
FrmSplash.ShowDialog() 'affiche la fenêtre Splash en Modale
FrmPrincipal.ShowDialog() 'a la fermeture de Splash, affiche la fenêtre principale End Sub
Dans Form1 (la fenêtre Splash)
Private Sub Form1_Activated Me.Refresh() 'pour afficher totalement la fenêtre.
'Ici ou on fait plein de choses on ouvre des fichiers ou on perd du temps.
Me.Close() End Sub
On affiche FrmSplash un moment (Ho! la belle image) puis on l'efface et on affiche la fenêtre principale. Word, Excel font comme cela.
Comment arrêter le programme ?
Me.Close() 'Ferme la fenêtre en cours Noter bien Me désigne le formulaire, la fenêtre en cours.
() 'Ferme l'application
Si des fichiers sont encore ouverts, cela les ferme. (Il vaut mieux les fermer avant, intentionnellement par une procédure qui ferme tous les fichiers.)
Rappel:Formulaire=fenêtre
Comment à partir d'un formulaire Form1 ouvrir un second formulaire Form2 ?
A-On va d'abord créer la Classe Form2
Ajouter un formulaire (Menu Projet, Ajouter un formulaire au projet) nommé Form2 .
On se rend compte que quand on ajoute un formulaire (Form2 par exemple), VB crée une nouvelle classe' Class Form2'qui hérite de , qui hérite donc de toutes les propriétés et méthodes de la Classe Form qui est la classe 'formulaire'. Public Class Form2 End Class
Elle contient du code généré automatiquement par le concepteur Windows Forms et les procédures liées aux évènements. Dessinez dans Form2 les contrôles nécessaires.
B-On va créer la fenêtre
Pour créer un nouveau formulaire dans le programme, il faut :
- Créer un formulaire à partir du moule, de la Classe Form2, cela s’appelle ‘Instancer’ un formulaire avec le mot New.
- Ouvrir ce formulaire, la faire apparaître, (avec ShowDialog, c’est un formulaire modal)
Dim f As New Form2() f.ShowDialog()
En conclusion :
Le fait d'ajouter un formulaire et des contrôles à un projet crée une Class, (un moule) ce qui permet ensuite d'instancer un objet formulaire.
Une procédure crée un formulaire par Dim f As New Form2 - Dans le formulaire f créé:
Utiliser Me pour désigner le formulaire où on se trouve. (Form2 ou f ne sont pas acceptés)
Exemple :
Le formulaire f pourra être fermé par Me.close() dans le code du bouton Quitter par exemple. - Hors du formulaire f, dans la procédure où a été instancé le formulaire: Utiliser f pour désigner le formulaire.
Exemple :
Si la fenêtre appelante veut récupérer des informations dans le formulaire f (un texte dans txtMessage par exemple), il faudra écrire.
- Par contre, hors de la procédure qui a créée le formulaire, f n'est pas accessible.
En résumé: Attention donc, si vous instancez un formulaire dans une procédure, elle sera visible et accessible uniquement dans cette procédure.
Cela parait évident car un formulaire est un objet comme un autre et sa visibilité obéit aux règles habituelles (J'ai mis malgré tout un certains temps à le comprendre!!!).
Si vous voulez créer un formulaire qui soit visible dans la totalité du programme et dont les contrôles ou propriétés soient accessible par l'ensemble du programme, il faut l'instancer dans un module standard avec :
Public f As New Form2.
Un formulaire est un objet et sa visibilité obéit aux règles habituelles: Il peut être instancé dans une procédure, un module, précédé de ‘Public’,'Private' Ce qui permet de gérer son accessibilité.
Pour ajouter une méthode à un formulaire, il faut créer une Sub Public dans le corps de la fenêtre :
Public Sub Imprime() Code d'impression
End Sub
Si une instance de la fenêtre se nomme F, F.Imprime() exécute la méthode Imprime (donc la sub Imprime)
De même, pour définir un membre d'un formulaire, il faut ajouter une variable public. Public Utilisateur As String
Permet d'utiliser en dehors du formulaire F.Utilisateur
Si le formulaire é été instancé dans un module de Classe et précédé de Public, les méthodes et propriétés de ce formulaire seront accessibles de partout.
Exemple plus completAvec récupération de données dans le formulaire créé, à partir d'une procédure :
Créer un formulaire en utilisant Form2.
L'ouvrir en formulaire modal.Quand l'utilisateur ferme cette fenêtre modale, récupérer le texte qui est dans txtMessage de cette fenêtre modale.
La ruse c'est de mettre dans le code du bouton Quitter de Form2 () pour rendre la fenêtre Form2 invisible mais accessible (et pas Me.Close() qui détruirait la fenêtre, le contrôle txtMessage et son contenu).
Dim f As New Form2()
f.ShowDialog() f.Close()
Une fois que le texte à été récupéré, on faire disparaître la fenêtre f.
En réalité, curieusement, il semble que les propriétés de f soient accessibles même après un Close!!!
Autre problème, comment savoir si un formulaire existe, s’il n’existe pas le créer, s’il existe le rendre visible et lui donner la main :
If f Is Nothing Then 'Si f=rien f = New Form2 f.ShowDialog() Else
If f.Visible = False Then
f.Visible = True
End If
f.Activate()
End If
Un formulaire modal est un formulaire qui une fois ouvert prend la main, interdit l'usage des autres fenêtres. Pour poursuivre, on ne peut que sortir de cette fenêtre.
Exemple typique : une MessageBox est un formulaire modal, les fenêtres d'avertissement dans Windows sont aussi modales.
Pour ouvrir un formulaire modal, il faut utiliser la méthode .ShowDialog
f.ShowDialog()
Noter, et c'est très important, que le code qui suit .showDialog est exécuté après la fermeture de la fenêtre modale.
Pour un formulaire non modal faire :
f.Show()
Dans ce cas le formulaire f s'ouvre, le code qui suit .Show est exécuté immédiatement, et il est possible de passer dans une autre fenêtre de l'application sans fermer f.
Comment savoir quel formulaire a ouvert le formulaire en cours ? (Quel est le formulaire parent?)
ShowDialog possède un argument facultatif, owner, qu'on peut utiliser afin de spécifier une relation parent-enfant pour un formulaire. Par exemple, lorsque le code de votre formulaire principal affiche une boîte de dialogue, vous pouvez passer Me comme propriétaire de la boîte de dialogue, afin de désigner votre formulaire principal comme propriétaire, comme le montre le code de l'exemple suivant :
Dans Form1
Dim f As New Form2 f.ShowDialog(Me)
Dans Form2 on peut récupérer le nom du 'propriétaire', du 'parent' qui a ouvert la fenêtre (il est dans Owner) et l'afficher par exemple : =Me.Owner.ToString
Cela affiche : NomApplication.Form1,text text=est le texte de la barre supérieure. Récupération d’information par DialogResult
On ouvre un formulaire modal, comment, après sa fermeture, récupérer des informations sur ce qui s'est passé dans ce formulaire modale ?
Par exemple, l'utilisateur a t-il cliqué sur le bouton Ok ou le bouton Cancel pour fermer le formulaire modale ?
Pour cela on va utiliser une propriété DialogResult des boutons, y mettre une valeur correspondant au bouton, quand l'utilisateur clique sur un bouton, la valeur de la propriété DialogResult du bouton est assignée à la propriété DialogResult du formulaire, on récupère cette valeur à la fermeture du formulaire modal.
Dans le formulaire modal Form2 on met :
ButtonOk.DialogResult=
ButtonCancel.DialogResult= DialogResult.Cancel
Dans le formulaire qui appelle :
Form2.ShowDialog()
If form2.DialogResult= then
'l'utilisateur a cliquer sur le bouton ok
End if
Remarque :
1. On utilise comme valeur de DialogResult les constantes de l'énumération
.Cancel .No .Yes .Retry .None
2. Si l'utilisateur clique sur la fermeture du formulaire modal (bouton avec X) cela retourne DialogResult.cancel
3. on peut aussi utiliser la syntaxe : If form2.ShowDialog(Me) =
Then qui permet en une seule ligne d'ouvrir form2 et de tester si l'utilisateur a cliqué sur le bouton ok de form2.
4. La fermeture du formulaire modal par le bouton de fermeture ou l'appel de la méthode Close ne détruit pas toujours le formulaire modal, il faut dans ce cas utiliser la méthode Dispose pour le détruire.
Mon truc:De manière générale s'il y a des informations à faire passer d'un formulaire à un autre, j'utilise une variable Publique (nommée BAL comme 'Boite aux lettres' par exemple) dans laquelle je met l'information à faire passer.
Parfois dans un formulaire, l'utilisateur doit pouvoir, valider (taper sur la touche 'Entrée') pour accepter et quitter rapidement le formulaire (c'est l'équivalent du bouton 'Ok') ou taper 'Echap' pour sortir du formulaire sans accepter (c'est l'équivalent du bouton 'Cancel').
Il suffit pour cela de donner aux propriétés AcceptButton et CancelButton du formulaire, le nom des boutons ok et cancel qui sont sur la feuille.
form1.AcceptButton = buttonOk form1.CancelButton = buttonCancel
Si l'utilisateur tape la touche 'Echap' buttonCancel_Click est exécuté.
Il y a plusieurs types d'erreurs :
- Les erreurs de syntaxe.
- Les erreurs d'exécution.
- Les erreurs de logique.
Elles surviennent en mode conception quand on tape le code :
Exemple :
A+1=B 'Erreur dans l'affectation
f.ShowDialogue 'Faute de frappe, il fallait taper ShowDialog
2 For et un seul Next
Dans ces cas VB souligne en ondulé bleue le code. Il faut mettre le curseur sur le mot souligné, l'explication de l'erreur apparaît.
Exemple : Propriété Text d'un label mal orthographiée.
Elles sont parfois détectées en mode Run.
Erreur dans une conversion de type de données par exemple. Il faut les corriger immédiatement en tapant le bon code.
Elles surviennent en mode Run ou lors de l'utilisation de l'exécutable, une instruction ne peut pas être effectuée. Le logiciel s'arrête brutalement, c'est très gênant!! Pour l'utilisateur c'est un 'BUG'
L'erreur est:
- Soit une erreur de conception.
Exemple :
Ouvrir un fichier qui n'existe pas (On aurait du vérifier qu'il existe avant de l'ouvrir!). Division par zéro.
Utiliser un index d'élément de tableau supérieur au plus grand possible : Dim A(3) As String: A(5)="Toto" - Soit une erreur de l'utilisateur.
Exemple : On lui demande de taper un chiffre, il tape une lettre ou rien puis valide.
Il faut toujours vérifier ce que fait l'utilisateur et prévoir toutes les possibilités.
Exemple :
Si je demande à l'utilisateur de tapez un nombre entre 1 et 10, il faut: - Vérifier qu'il a tapé quelque chose.
- Que c'est bien un chiffre (pas des lettres). - Que le chiffre est bien entre 1 et 10. Sinon il faudra reposer la question.
On voit bien que pour éviter les erreurs d'exécution il est possible :
- D'écrire du code gérant ces problèmes, contrôlant les actions de l'utilisateur… - Une autre alternative est de capter l'erreur.
Capter les erreurs avec Try Catch Finally
Avant l'instruction supposée provoquer une erreur indiquez : Essayer (Try), si une erreur se produit Intercepter l'erreur (Catch) puis poursuivre (après Finally) Try
Instruction susceptible de provoquer une erreur Catch
Traitement de l'erreur
Finally
Code toujours exécuté
End Try
Il faut pour que cela fonctionne avoir tapé au préalable Imports
Il est possible d'utiliser Catch pour récupérer l'objet 'Exception' qui est généré par l'erreur. Catch ex As Exception
Cet objet Exception à des propriétés :
Message qui contient le descriptif de l'erreur.
Source qui contient l'objet qui a provoqué l'erreur .
ex.Message contient donc le message de l'erreur.
Cet objet Exception (de l'espace IO) à aussi des classes dérivées : StackOverFlowException; FileNotFoundExeption; EndOfStreamExeption; FileLoadExeption; PathTooLongExeption.
Enfin une exception peut provenir de l'espace System: ArgumentExceptions; ArithmeticException; DivideByZeroExeception ..
Il est possible d'écrire plusieurs instructions Catch avec pour chacune le type de l'erreur à intercepter. (Faisant partie de la classe Exceptions)
Exemple :
On ouvre un fichier par StreamReader , comment intercepter les exceptions suivantes?
Répertoire non valide Fichier non valide Autre.
Try sr= New StreamerReader (NomFichier)
Catch ex As DirectoryNotFoundException
MsgBox("Répertoire invalide")
Catch ex As FileNotFoundException MsgBox("Fichier invalide")
Catch ex As Exception
MsgBox(ex.Message)
End Try
Noter que le dernier Catch intercepte toutes les autres exceptions.
On peut encore affiner la gestion par le mot clé When qui permet une condition.
Catch ex As FileNotFoundException
When ex.Message.IndexOf ("Mon ") >0 MsgBox ("Impossible d'ouvrir Mon ")
Si le texte "Mon " est dans le message, affichez que c'est lui qui ne peut pas être ouvert.
Exit Try permet de sortir prématurément.
Capter les erreurs avec On error
On peut aussi utiliser en la méthode VB6 :
On Error Goto permet en cas d'erreur de sauter à une portion de code traitant l'erreur. On peut y lire le numéro de l'erreur qui s'est produite, ce numéro est dans Err.Number.
Err.Description contient le texte décrivant l'erreur. Err.Source donne le nom de l'objet ou de l'application qui a crée l'erreur.
Quand l'erreur est corrigée, on peut revenir de nouveau effectuer la ligne qui a provoqué l'erreur grâce à Resume ou poursuivre à la ligne suivante grâce à Resume Next
Exemple :
On Error GoTo RoutinedErreur 'Si une erreur se produit se rendre à 'RoutineErreur'
Dim x As Integer = 33
Dim y As Integer = 0 Dim z As Integer z = x / y ' Crée une division par 0 !!
RoutinedErreur: ' La Routine d'erreur est ici (remarquer le ':').
Select Case Err.Number ' On regarde le numéro de l'erreur.
Case 6 ' Cas : Division par zéro interdite y = 1 ' corrige l'erreur.
Case Else
' Autres erreurs .
End Select Resume ' Retour à la ligne qui a provoqué l'erreur.
Pour arrêter la gestion des erreurs il faut utiliser :
On Error Goto 0 Parfois on utilise une gestion hyper simplifiée des erreurs:
Si une instruction 'plante', la sauter et passez à l'instruction suivante, pour cela on utilise: On Error Resume Next
Exemple :
On veut effacer un fichier On Error Resume Next
Kill (MonFichier) On Error goto 0
Ainsi, si le fichier n'existe pas, cela ne plante pas (on aurait pu aussi vérifier qu'il existe avant de l'effacer).
On Error Gosub n'existe plus.
Le programme fonctionne, pas d'erreurs apparentes, mais les résultats sont erronés, faux.
Il faut donc toujours tester le fonctionnement du programme de multiples fois dans les conditions réelles avec des données courantes, mais aussi avec des données remarquables (limites supérieures, inférieures, cas particuliers..) pour voir si les résultats sont cohérents et exacts.
Et avoir une armée de Bêta-testeurs.Une fois l'erreur trouvée, il faut en déterminer la cause et la corriger.
Ou bien elle est évidente à la lecture du code ou bien elle n'est pas évidente et c'est l'horreur. Dans ce dernier cas il faut analyser le fonctionnement du programme pas à pas, instruction par instruction en surveillant la valeur des variables. (Voir la rubrique déboguage)
Les erreurs les plus communes sont :
- Utilisation d'un mauvais nom de variable (La déclaration obligatoire des variables évite cela)
- Erreur dans la portée d'une variable.
- Erreur dans le passage de paramètres (Attention au By Val et By Ref) - Erreur dans la conception de l'algorithme. -
Quelques règles permettent de les éviter : voir leçon 7.2
Comment créer un programme MDI (Multi Document Interface) ?
L’exemple de Word : la fenêtre principale (fenêtres MDI) contient les menus en haut, on peut ouvrir plusieurs documents dans des fenêtres filles. Ci dessous l'exemple de LDF (Programme de comptabilité écrit par l'auteur) :
On a une fenêtre MDI (conteneur) contenant 2 fenêtres filles affichant chacune une année de comptabilité.
Dans , un MDIForm (fenêtres principale MDI) est une fenêtre quelconque dont la propriété IsMDIContainer = true.
Dans la fenêtre fille, la propriété MDIParent indique le conteneur (C'est à dire le nom de la fenêtre MDI).
Les applications MDI peuvent avoir plusieurs conteneurs MDI.
Exemple d'un programme MDI.
On va créer une Form1 qui est le conteneur.
Une Form2 qui est la fenêtre fille.
Dans Form1 le menu principal contient la ligne '&Nouvelle' qui crée une nouvelle instance de la fenêtre fille.
Création de la fenêtre conteneur parent Créer la fenêtre Form1 :
Dans la fenêtre Propriétés, affectez la valeur true à la propriété IsMDIContainer. Ce faisant, vous désignez la fenêtre comme le conteneur MDI des fenêtres enfants.
Remarque : Affecter la valeur Maximized à la propriété WindowState, car il est plus facile de manipuler des fenêtres MDI enfants lorsque le formulaire parent est agrandi. Sachez par ailleurs que le formulaire MDI parent prend la couleur système (définie dans le Panneau de configuration Windows).
Ajouter les menus du conteneur :
A partir de la boîte à outils, faites glisser un contrôle MainMenu sur le formulaire. Créez un élément de menu de niveau supérieur en définissant la propriété Text avec la valeur &File et des éléments de sous-menu appelés &Nouvelle et &Close. Créez également un élément de menu de niveau supérieur appelé &Fenêtre.
Dans la liste déroulante située en haut de la fenêtre Propriétés, sélectionnez l'élément de menu correspondant à l'élément &Fenêtre et affectez la valeur true à la propriété MdiList.
Vous activez ainsi le menu Fenêtre qui permet de tenir à jour une liste des fenêtres MDI enfants ouvertes et indique à l'utilisateur par une coche la fenêtre enfant active.
Il est conseillé de créer un module standard qui instance la fenêtre principale et qui contient une procédure Main qui affiche la fenêtre principale :
Module StandartGénéral
Public FrmMDI as Form1
Sub Main()
FrmMDI.ShowDialog()
End sub End Module
Noter bien que FrmMDI est donc la fenêtre conteneur et est Public donc accessible à tous.
Pour créer une fenêtre fille, il suffit de donner à la propriété MDIParent d'une fenêtre le nom de la fenêtre conteneur. Dessiner dans Form2 les objets nécessaires dans la fenêtre fille.
Comment créer une instance de la fenêtre fille à chaque fois que l'utilisateur clique sur le menu '&Nouvelle'?
En premier lieu, déclarez dans le haut du formulaire Form1 une variable MDIFilleActive qui contiendra la fenêtre fille active.
Dim MDIFilleActive As Form2
La routine correspondant au MenuItem &Nouvelle (dans la fenêtre MDI) doit créer une instance de la fenêtre fille :
Protected Sub MDIChildNouvelle_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MenuItem2.Click
MDIFilleActive = New Form2() 'Indique à la fenêtre fille son ‘parent’.
MDIFilleActive.MdiParent = Me
'Affiche la fenêtre fille
()
End Sub
Comment connaître la fenêtre fille active ?
Quand on en a ouvert plusieurs ?
La fenêtre fille active est dans Me.ActiveMdiChild du conteneur
Comment voir s'il existe une fenêtre active ?
If Not (ActiveMdiChild=Nothing) then 'elle existe
En mettant dans la variable MDIFilleActive la fenêtre active, on est sur de l'avoir toujours à disposition : pour cela dans la procédure Form1_MdiActivate (qui se produit à chaque fois que l'on change de fenêtre fille) je récupère Me.ActiveMdiChild qui retourne la fenêtre fille active.
Dans Form1
Private Sub Form1_MdiChildActivate.. MDIFilleActive=Me.ActiveMdiChild End Sub
Il faut comprendre que peut importe le nom de la fenêtre fille active, on sait simplement que la fenêtre fille active est dans MIDFilleActive, variable que l'on utilise pour travailler sur cette fenêtre fille.
Comment avoir accès aux objets de la fenêtre fille à partir du conteneur ?
De la fenêtre conteneur j'ai accès aux objets de la fenêtre fille par l'intermédiaire de la variable MDIFilleActive précédemment mise à jour; par exemple le texte d'un label :
Comment parcourir toutes les fenêtres filles ?
La collection MdiChildren contient toutes les fenêtres filles, on peut les parcourir : Dim ff As Form2
For Each ff In Me.MdiChildren
Nex t
Comment avoir accès aux objets du conteneur à partir de la fenêtre fille ?
En utilisant Me.MdiParent qui contient le nom du conteneur.
Dans la fenêtre fille le code ="Document 1" affichera 'Document 1' dans la barre de titre du conteneur.
Comment une routine du module conteneur appelle une routine dans la fenêtre fille active ?
Si une routine public de la fenêtre fille se nomme Affiche, on peut l'appeler par : MDIFilleActive.Affiche()
Il n'est pas possible d'appeler les évènements liés aux objets.
La propriété LayoutMdi de la fenêtre conteneur modifie l’agencement des fenêtres filles.
0 - MdiLayout.Cascade
1 - MdiLayout.TileHorizontal
2 - MdiLayout.TileVertical
3 - MdiLayout.ArrangeIcons Exemple :
Le menu Item Cascade met les fenêtres filles en cascade.
Protected Sub CascadeWindows_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs)
Me.LayoutMdi(System.Windows.Forms.MdiLayout.Cascade)
End Sub
On a vu qu'il existe un type de variable 'DateTime' pour gérer les dates et heures, comment l'utiliser ?
Nous verrons aussi comment utiliser les Timers pour déclencher des évènements à intervalle régulier.
Enfin comment perdre du temps ?
Une variable DateTime ‘Contient une date plus l’heure.
Elle occupe 8 octets. (64 bits)
Peut contenir une date comprises entre le 1erjanvier de l'année 1 et le 31 décembre 9999 et des heures comprises entre 0:00:00 (minuit) et 23:59:59.
En fait ce qui est codé dans la variable DateTime est le nombre de graduations (Une graduation= 100 nanosecondes.) écoulées à compter de minuit, le 1er janvier de l'année 1 jusqu'a la date codée.
Nb: DateTime fait partie d'une Classe .Net , il existe aussi un type nommé Date qui contient aussi une date et l'heure et qui fait partie de VB mais qui n'est pas une classe.
Pour saisir une valeur DateTime en utilisant un littéral: elle doit être placée entre des signes (#) et son format doit être de type d/m/yyyy, par exemple #31/5/1998#.
Dim DateNaissance As Date DateNaissance= #02/12/1951#
Autre manière de saisir une date, une heure :
Dim date1 As New System.DateTime(1996, 6, 3, 22, 15, 0) 'Année, mois, jour, heure,minute, seconde, et éventuellement millisecondes)
Pour afficher les dates et heures simplement, il suffit d'utiliser .ToString
MsgBox(DateNaissance.ToString) 'Affichera 02/12/1951 11:00:00
C'est le format utilisé par l'ordinateur (en fonction du pays) ToString peut comporter des arguments qui formatent l'affichage :
Voici quelques codes de formatage:
D affiche le jour 2
|
Dd affiche le jour sur 2 chiffres |
02 |
|
Ddd affiche le jour abrégé |
Dim. |
|
Dddd affiche le jour complet |
Dimanche |
|
M affiche le mois |
12 |
|
MM affiche le mois sur 2 chiffres |
12 |
|
MMM affiche le mois abrégé |
déc |
|
MMMM affiche le mois complet |
décembre |
y, yy, yyyy affiche 1 à 2 chiffres, deux chiffres ou quatre chiffre 51, 51, 1951
H affiche l'heure sur un ou deux chiffres (format 24h) HH affiche l'heure sur 2 chiffres h et hh font de même mais avec un format 12 h.
t, tt affiche l'heure en format 12h plus A ou P (pour matin, après midi) m, mm, s, ss, f, ff font de même pour les minutes, secondes et millisecondes. : et / sont les séparateurs heure et date.
Exemple :
MsgBox(DateNaissance.ToString("dddd d MMMM yyyy")) 'Affichera Dimanche 2 décembre 1951
MsgBox(DateNaissance.ToString("hh:mm") 'Affichera 11:00
MsgBox(DateNaissance.ToString("d/MM/yy") 'Affichera 02/12/51
MsgBox(DateNaissance.ToString("%h) 'Affichera 11 le caractère % est utilisé quand on affiche une seule donnée.
On peut enfin utiliser les méthodes de la classe DateTime!!
|
DateNaissance.ToLongDateString |
'dimanche 02 décembre 1951 |
|
DateNaissance.ToShortDateString |
‘02/12/1951 |
|
DateNaissance.ToLongTimeString |
'11:00:00 |
|
DateNaissance.ToShortTimeString |
'11:00 |
Un TimeSpan est une unité de temps exprimée en jours, heures, minutes, secondes; Un TimeSpan initialisé avec 1.0e+13 graduations représente "11.13:46:40", ce qui correspond à 11 jours, 13 heures, 46 minutes et 40 secondes.
L'espace de nom System.DateTime. contient une multitude de membre :
On peut ajouter ou soustraire un TimeSpan à un DateTime, on obtient un DateTime.
En clair on peut ajouter à une date une durée, on obtient une date.
' Quel sera la date dans 36 jours ? Dim today As System.DateTime
Dim duration As System.TimeSpan Dim answer As System.DateTime
today = duration = New System.TimeSpan(36, 0, 0, 0) answer = (duration)
On peut ajouter ou soustraire 2 dates, on obtient une TimeSpan
Dim diff1 As System.TimeSpan diff1 = date2.Subtract(date1)
Permet d'ajouter des jours,ou des mois, ou des heures, ou des secondes, ou des millisecondes à une date, on obtient une date. Answer=today.AddDay(36)
Permettent d'extraire l'année, le mois, le jour, l'heure, les minutes, les secondes, les millisecondes d'une date :
' => I=1951
'donne le jour d'aujourd'hui (1 à 31)
Retourne le jour de la semaine (0 pour dimanche à 6 pour samedi)
I=DateNaissance.DayOfWeek 'I=0 car le 02/12/1951 est un dimanche. DayForYear existe aussi.
Now est la date et l'heure du système.(Là, maintenant) ToDay est la date du système avec l'heure à 0. TimeOfDay est l'heure actuelle.
Donne le nombre de graduations d'un DateTime.
AddTicks peut être utilisé.
On utilise Compare: DateTime.Compare(t1, t2) retourne 0 si t1=t2, une valeur positive si t1>t2 négative si t1
Dim t1 As New DateTime(100) Dim t2 As New DateTime(20)
If DateTime.Compare(t1, t2) > 0 Then
Console.WriteLine("t1 > t2") End If
If DateTime.Compare(t1, t2) = 0 Then Console.WriteLine("t1 = t2") End If
If DateTime.Compare(t1, t2) < 0 Then Console.WriteLine("t1 < t2")
End If
On peut aussi utiliser la méthode op_Equality de l'espace de nom pour voir si 2 dates sont égales:
areEqual = System.DateTime.op_Equality(april19, otherDate)
Il existe aussi op_GreaterThan et beaucoup d'autres.
Comment saisir rapidement une date dans un programme?
En ajoutant à une fenêtre un contrôle DateTimePicker En mode Run, il apparaît une zone rectangulaire avec la date système dedans :
Si l'utilisateur clique sur la flèche déroulante, il apparaît une fenêtre calendrier.
Il suffit pour l'utilisateur de cliquer sur la bonne date.
Le programmeur récupére la date dans DateTimePicker1.value
Il existe, bien sur, de multiples propriétés et plusieurs évènements, le plus remarquable étant : ValueChanged.
MonthCalendar est un contrôle similaire mais qui reste toujours ouvert. De plus grâce à CalendarDimension on peut afficher plusieurs mois.
Pour déclencher un évènement à intervalle régulier, il faut utiliser les minuteries ou Timer. Prendre le contrôle Timer dans le Boite à outils, l'ajouter à la fenêtre. Il apparaît en bas sous la fenêtre dans la barre d'état des composants.
Il n'apparaît pas à l'utilisateur dans la fenêtre en mode Run. Il est très simple à utiliser.
La propriété Interval contient la périodicité de l'événement Ticks , évènement qui se déclenche régulièrement.
Interval est en millisecondes. Pour Interval=500 l'évènement Ticks se déclenche toutes les 1/2 secondes.
Start et Stop déclenche et arrête la minuterie. (De même Enabled active ou non)
Exemple :
Faire clignoter un label toutes les 1/2 secondes.
Créer le label1
Ajouter un Timer1 (qui se place en bas sous la fenêtre)
Private Sub Form3_Load( ) Timer1.Interval = 500
Timer1.Start()
End Sub
Private Sub Timer1_Tick(..)
Label1.Visible = Not (Label1.Visible)
End Sub
Un évènement Timer_Tick se produit toutes les 1/2 secondes et inverse la valeur de la propriété visible du label. (S'il était égal à True, il devient égal à False et vice versa.) Mais attention : Timer à des restrictions de taille :
- Si votre application ou une autre demande beaucoup au système (boucles longues, calculs complexes, accès intensifs à un périphérique, un réseau ou un port, par exemple), les événements de minuterie peuvent être moins fréquent que spécifié dans la propriété Interval. Il n'est pas garanti que l'intervalle s'écoule dans le temps exact!!
- L'intervalle peut être compris entre 1 et 64 767 millisecondes : l'intervalle le plus long ne dépasse pas de beaucoup la minute (64,8 secondes).
- Le système génère 18 graduations à la seconde (même si la valeur de la propriété Interval est mesurée en millisecondes, la véritable précision d'un intervalle ne dépassera pas un dix-huitième de seconde).
Donc pour faire clignoter un label : OUI
Pour compter précisément un intervalle de temps:NON Mais il y a d'autres méthodes, voir le cours 7.3
Parfois on a besoin de perdre du temps :
Exemple ne rien faire pendant 3 secondes puis poursuivre… - Il est exclu de faire des boucles vides:
For i=0 to 100000 ' le temps écoulé est variable en fonction des machines… Next i
- Autre méthode : on boucle tant que l'heure courante est inférieure à l'heure du départ+3s
Dim t As
Do While <t.AddSeconds(3)
Loop
Mais cela accapare le processeur.
- On peut utiliser un Timer et vérifier dans la procédure Tick si le temps est écoulé.
- On peut utiliser Thread.Sleep
System.Threading.Thread.Sleep(3000)
Parfois on a besoin de chronométrer un évènement :
Voir le cours 7.4 - Chronométrer
L'exemple E4.1sur l'horloge est aussi didactique.
Comment lire et écrire dans des fichiers du texte, des octets, du XML du Rtf ?
Le mot 'fichier' est a prendre au sens informatique : ce n'est pas un ensemble de fiches mais plutôt un ensemble d'octets. Un fichier peut être un programme (Extension .EXE), du texte (Extension .TXT ou .DOC .), une image (Extension .BMP .GIF .JPG ), une base de données (.MDB..) du son, de la vidéo .
Pour travailler avec du texte, des octets, des données très simple (sans nécessité d'index, de classement..), on utilise les méthodes décrites dans cette page, travail direct dans les fichiers séquentiels, aléatoires, binaires. Mais dès que les informations sont plus structurées, il faut utiliser les bases de données (Il y a plusieurs chapitre plus loin traitant des Base de données).
Un fichier a un nom : '', une extension : '.GIF' qui en indique généralement le type de contenu, des attributs (Longueur, Date de création, de modification, Fichier en lecture seule ou non..). On voit cela dans l'explorer Windows :
Un fichier est composé d'enregistrements qui sont des 'paquets' de données; suivant le type de fichiers un enregistrement peut correspondre à une ligne, un octet, un groupe d'octets…
Comment utiliser les fichiers, voici le plan de cet article :
Avec la Classe FileInfo.
On obtient des renseignements sur le fichier.
Pour lire écrire dans un fichier (en dehors des bases de données), il y a plusieurs méthodes.
Avec la Classe on a à notre disposition StreamReader StreamWriter BinaryReader BinaryWriter FileStream
Pour lire ou écrire dans un fichier, il faut l'ouvrir (Open), lire ou écrire en utilisant un flux de données (Stream) puis le refermer (Close).
Le Stream (flux, torrent, courant) est une notion générale, c'est donc un flux de données provenant ou allant vers un fichier, un port, une connexion TCP/IP
L'accès est séquentiel : les données sont traitées du début à la fin du fichier.
On ouvre le fichier en mode séquentiel, aléatoire, binaire, on lit X enregistrements, on referme le fichier.
Comme avec le RichTextBox par exemple.
En résumé, pour travailler sur les fichiers, on dispose :
- des instructions VB runtime traditionnelles: FileOpen WriteLine…
- des instructions du FSO (FileObjetSystem) pour la compatibilité avec les langages de script.
- de l'espace de nom avec les Class et objets .NET
Les 2 premiers font appel au troisième; donc pourquoi ne pas utiliser directement les Classe .NET?
Pour travailler sur les fichiers, il faut au préalable taper :
Imports
La classe File est utilisée pour travailler sur un ensemble de fichier ou un fichier (sans instanciation préalable), la Classe FileInfo donne des renseignements sur un fichier particulier (Il faut instancer au préalable un objet FileInfo). La Classe File possède les méthodes suivantes.
Exists Teste si le fichier existe.
Create Crée le fichier Copy Copie le fichier
Delete Efface le fichier
GetAttributes , SetAttributes Lire ou écrire les attributs
Move Déplacement de fichier
Toutes les méthodes Open (pour un FileStream) OpenRead, OpenWrite, OpenText.
Exemple :
Un fichier existe-t-il? Afficher True s'il existe :
= File.Exists("").ToString
La Classe FileInfo possède les propriétés suivantes.
Name Nom du fichier (sans extension)
FullName Nom complet avec extension
Extension Extension (.txt par exemple)
Length Longueur du fichier
Directory Répertoire parent
DirectoryName Répertoire ou se trouve le fichier
Exists
LastAccessTime Date du dernier accès, LastWriteTime existe aussi
Attributes Attributs
Il faut faire un AND entre Attributes et une valeur de l'énumération FileAttributes ( Archive, Compressed, Directory, Encrypted, Hidden, Normal, ReadOnly, System, Temporaly).
Pour tester ReadOnly par exemple :
Fi.Attributes And FileAttributes.ReadOnly
'retourne True si le fichier est ReadOnly
Et les méthodes suivantes :
Create, Delete, MoveToAppendTex, CopyTo Open, OpenRead, OpenWrite, OpenText..
On voit que toutes les informations sont accessibles.
Exemple :
Pour un fichier, afficher successivement le nom, le nom avec répertoire, le répertoire, la longueur, la date de dernière écriture et si le fichier est en ReadOnly. Dim sNom As String = "c:\"
Dim Fi As FileInfo
Fi=New FileInfo( sNom)
MsgBox("Nom="& )
MsgBox("Nom complet ="& Fi.FullName)
MsgBox("Répertoire="& Fi.DirectoryName)
MsgBox("Longueur="& Fi.Lenght.ToString)
MsgBox("Date der modification="& Fi.LastWriteTime.ToShortDateString)
MsgBox("ReadOnly="& (Fi.Attributes And FileAttributes.ReadOnly).ToString)
Le Stream (flux, torrent, courant) est une notion générale, c'est donc un flux de données provenant ou allant vers un fichier, un port, une connexion TCP/IP
Ici on utilise un Stream pour lire ou écrire dans un fichier. L'accès est séquentiel: les données sont traitées du début à la fin du fichier.
Pour écrire dans un fichier texte :
Il faut instancier un objet de la classe StreamWriter. On écrit avec Write ou WriteLine (ajoute un saut de ligne). Enfin on ferme avec Close.
On peut instancer avec le constructeur de la classe StreamWriter et avec New, ou par la Classe
File.
Dim SW As New StreamWriter ("") ' crée ou si existe écrase
Il existe une surcharge permettant d'ajouter à la fin du fichier :
Dim SW As New StreamWriter ("", True) ' crée ou si existe ajoute
Avec la classe File :
Dim SW As StreamWriter=File.CreateText ("") ' crée ou si existe écrase Dim SW As StreamWriter = File.AppendText("") ' crée ou si existe ajoute
Ensuite pour écrire 2 lignes : SW.WriteLine ("Bonjour") SW.WriteLine ("Monsieur")
Enfin on ferme :
SW.Close()
Pour lire dans un fichier Texte :
Il faut instancier un objet de la classe StreamReader. On lit avec Read (un nombre d'octet) ReadLine (une ligne) ReadToEnd (de la position courante jusqu'à la fin). Enfin on ferme avec Close.
Avec le constructeur de la Classe Stream Reader :
Dim SR As New StreamReader ("")
Avec la Classe File :
Dim SR As StreamReader=File.OpenText ("") Comment lire chaque ligne du fichier et s'arrêter à la fin ?
En effet on ne sait pas habituellement combien le fichier contient de ligne, si le fichier contient 2 lignes il faut en lire 2 et s'arrêter sinon on tente de lire après la fin du fichier, encore cela déclenche une erreur.
3 solutions :
1-Utiliser ReadToEnd qui lit en bloc jusqu'à la fin.
2-Avant ReadLine Taper un Try, quand l'erreur 'fin de fichier' survient elle est intercepté par Catch qui sort du cycle de lecture et ferme le fichier.
3-Utiliser Peek qui lit dans le fichier un caractère mais sans modifier la position courante de lecture.
La particularité de Peek est de retourner -1 s'il n'y a plus de caractère à lire sans déclencher d'erreur, d'exception.
La troisième solution est la plus générale et la plus élégante :
Do Until =-1
Ligne=SR.ReadLine()
Loop
Enfin on ferme :
SR.Close()
Notion de 'Buffer', utilisation de Flush.
En fait quand on écrit des informations sur le disque, le logiciel travaille sur un buffer ou mémoire tampon qui est en mémoire vive. Si on écrit des lignes dans le fichier, elles sont 'écrites' dans le buffer en mémoire vive. Quand le buffer est plein,(ou que l'on ferme le fichier) l'enregistrement du contenu du buffer est effectué effectivement sur le disque.
Ce procédé est général à l'écriture et à la lecture de fichier mais totalement transparent car le programmeur ne se préoccupe pas des buffers.
Parfois, par contre, même si on a enregistré peu d'information, on veut être sûr qu'elle est sur le disque, il faut donc forcer l'enregistrement sur disque même si le buffer n'est pas plein, on utilise la méthode Flush.
SW.Flush()
Le fait de fermer un fichier par Close, appelle automatiquement Flush() ce qui enregistre des données du buffer.
Visual Basic fournit trois types d'accès au fichier :
- l'accès séquentiel, pour lire et écrire des fichiers texte de manière continue, chaque donnée est enregistrée successivement du début à la fin ; les enregistrements n'ont pas la même longueur, ils sont séparés par des virgules ou des retours à la ligne.
Philippe
Jean- François Louis
On ne peut qu'écrire le premier enregistrement puis le second, le troisième, le quatrième
Pour lire c'est pareil : on ouvre, on lit le premier, le second, le troisième, le quatrième .
Pour lire le troisième enregistrement, il faut lire avant les 2 premiers.
- l'accès aléatoire (Random), (on le nomme parfois accès direct) pour lire et écrire des fichiers texte ou binaire constitués d'enregistrements de longueur fixe, on peut avoir directement accès à un enregistrement à partir de son numéro.
|
Philippe 1 place de la gare |
|
Jean 35 rue du cloître |
|
Pierre 14 impasse du musée |
|
Louis sdf |
Les enregistrements ont une longueur fixe, il faut prévoir!! Si on décide de 20 caractères pour le prénom, on ne pourra pas en mettre 21, le 21ème sera tronqué, à l'inverse l'enregistrement de 15 caractères sera complété par des blancs. Il n'y a pas de séparateur entre les enregistrements.
Les enregistrements peuvent être constitués d'un ensemble de variables : une structure, ici prénom et adresse. Ensuite on peut lire directement le second enregistrement, ou écrire sur le 3éme.
- l'accès binaire, pour lire et écrire dans tous les fichiers, on lit ou écrit un nombre d'octet désiré… En pratique :
Les fichiers séquentiels sont bien pratiques pour charger une série de ligne, (toujours la même) dans une ListBox par exemple.
Faut-il utiliser les fichiers séquentiels ou random (à accès aléatoire) pour créer par exemple un petit carnet d'adresse ?
Il y a 2 manières de faire :
- Créer un fichier random et lire ou écrire dans un enregistrement pour lire ou modifier une adresse.
- Créer un fichier séquentiel. A l'ouverture du logiciel lire séquentiellement toutes les adresses et les mettre dans un tableau (de structure). Pour lire ou modifier une adresse: lire ou modifier un élément du tableau. En sortant du programme enregistrer tous les éléments du tableau séquentiellement.(Enregistrer dans un nouveau fichier, effacer l'ancien, renommer le nouveau avec le nom de l'ancien).
- Bien sur s'il y a de nombreux éléments dans une adresse, un grand nombre d'adresse, il faut utiliser une base de données.
Si on ouvre un fichier en écriture et qu'il n'existe pas sur le disque, il est crée.
Si on ouvre un fichier en lecture et qu'il n'existe pas, une exception est déclenchée(une erreur). On utilisait cela pour voir si un fichier existait: on l'ouvrait, s'il n'y avait pas d'erreur c'est qu'il existait. Mais maintenant il y a plus simple pour voir si un fichier existe.
Si on ouvre un fichier et que celui-ci est déjà ouvert par un autre programme, il se déclenche généralement une erreur (sauf si on l'ouvre en Binaire, c'était le cas en VB6, c'est à vérifier en ).
Pour ouvrir un fichier on utilise FileOpen
Paramètres de FileOpen :FileNumber
A tous fichier est affecté un numéro unique, c'est ce numéro que l'on utilisera pour indiquer sur quel fichier pratiquer une opération Utilisez la fonction FreeFile pour obtenir le prochain numéro de fichier disponible.
FileName
Obligatoire. Expression de type String spécifiant un nom de fichier. Peut comprendre un nom de répertoire ou de dossier, et un nom de lecteur.
Mode
Obligatoire. Énumération OpenMode spécifiant le mode d'accès au fichier : Append, Binary, Input (séquentiel en lecture), Output (séquentiel en écriture) ou Random (accès aléatoire).
Access
Facultatif. Mot clé spécifiant les opérations autorisées sur le fichier ouvert : Read, Write ou ReadWrite. Par défaut, la valeur est OpenAccess.ReadWrite.
Share
Facultatif. Spécifiant si un autre programme peut avoir en même temps accès au même fichier : Shared (permet l'accès aux autres programmes), Lock Read (interdit
l'accès en lecture), Lock Write (interdit l'accès en écriture) et Lock Read Write(interdit totalement l'accès). Le processus Read Write est paramétré par défaut.
RecordLength
Facultatif. Nombre inférieur ou égal à 32 767 (octets). Pour les fichiers ouverts en mode Random, cette valeur représente la longueur de l'enregistrement. Pour les fichiers séquentiels, elle représente le nombre de caractères contenus dans la mémoire tampon.
Pour écrire dans un fichier on utilise :
Print, Write, WriteLine, dans les fichiers séquentiels FilePut dans les fichiers aléatoires Pour lire dans un fichier on utilise:
Input, LineInput dans les fichiers séquentiels FileGet dans les fichiers aléatoires.
Pour fermer le fichier on utilise FileClose()
Numéro de fichier :
Pour repérer chaque fichier, on lui donne un numéro unique (de type Integer). La fonction FreeFile retourne le premier numéro libre.
Dim No as integer No= Freefile()
Ensuite on peut utiliser No
FileOpen( No, "MonFichier", OpenMode.Output)
Print(No,"toto") FileClose (No)
1-Fichier séquentiel :
Vous devez spécifier si vous voulez lire (entrer) des caractères issus du fichier (mode Input), écrire (sortir) des caractères vers le fichier (mode Output) ou ajouter des caractères au fichier (mode Append).
Ouvrir le fichier 'MonFichier' en mode séquentiel pour y écrire : Dim No as integer
No= Freefile
FileOpen( No, "MonFichier", OpenMode.Output)
Pour écrire dans le fichier séquentiel: on utilise Write ou WriteLine Print ou PrintLine:
- La fonction Print écrit dans le fichier sans aucun caractère de séparation. Print(1,"toto")
Print(1,"tata") Print(1, 1.2)
Donne le fichier 'tototata1.2'
- La fonction Write insère des virgules entre les éléments et des guillemets de part et d'autre des chaînes au moment de leur écriture dans le fichier, les valeurs booléens et les variables DateTime sont écrites sans problèmes.
Write(1,"toto")
Write(1,"tata") Write(1, 1.2)
Donne le fichier '"toto";"tata";1.2"
Attention s'il y a des virgules dans les chaînes, elles seront considérées comme séparateurs!! Ce qui entraîne des erreurs à la lecture; il faut mettre la chaîne entre "" ou bien si c'est un séparateur décimal, le remplacer par un point. On peut aussi remplacer la virgule par un caractère non utilisé (# par exemple) avant de l'enregistrer puis après la lecture remplacer '#' par ','
Il faut utiliser Input pour relire ces données (Input utilise aussi la virgule comme séparateur.
• La fonction WriteLine insère un caractère de passage à la ligne, c'est-à-dire un retour chariot+ saut de ligne (Chr(13) + Chr(10)),On lira les données par LineInput. WriteLine(1,"toto")
WriteLine(1,"tata") WriteLine(1, 1.2)
Donne le fichier
"toto" "tata" 1.2
Il faut utiliser LineInput pour relire ces données car il lit jusqu'au retour Chariot, saut de ligne.
Toutes les données écrites dans le fichier à l'aide de la fonction Print respectent les conventions internationales, autrement dit les données sont mises en forme à l'aide du séparateur décimal approprié. Si l'utilisateur souhaite produire des données en vue d'une utilisation par plusieurs paramètres régionaux, il convient d'utiliser la fonction Write
EOF (NuméroFichier) veut dire 'End Of File', (Fin de Fichier) il prend la valeur True si on est à la fin du fichier et qu'il n'y a plus rien à lire. LOF (NuméroFichier) veut dire 'Lenght Of File', il retourne la longueur du fichier.
Exemple, lire chaque ligne d'un fichier texte :
Dim Line As String
FileOpen(1, "", OpenMode.Input) ' Ouvre en lecture. While Not EOF(1) ' Boucler jusqu'à la fin du fichier
Line = LineInput(1) ' Lire chaque ligne Debug.WriteLine(Line) ' Afficher chaque ligne sur la console.
End While
FileClose(1) ' Fermer.
Ici on a utilisé une boucle While… End While qui tourne tant que EOF est Faux. Quand on est à la fin du fichier EOF (End of File) devient égal à True et on sort de la boucle.
2-Fichier à accès aléatoire
On ouvre le fichier avec FileOpen et le mode OpenMode.Random, ensuite on peut écrire un enregistrement grâce à FilePut() ou en lire un grâce à FileGet(). On peut se positionner sur un enregistrement précis (le 2eme, le 15ème) avec Seek.
Le premier enregistrement est l'enregistrement numéro 1 Exemple:
Fichier des adresses
Créer une structure Adresse, on utilise <VBFixedString( )> pour fixer la longueur.
Public Structure Adresse
<VBFixedString(20)>Dim Nom As String
<VBFixedString(20)>Dim Rue As String
<VBFixedString(20)>Dim Ville As String
End Structure
'Ouvrir le fichier, comme il n'existe pas, cela entraîne sa création
Dim FileNum As Integer, RecLength As Long, UneAdresse As Adresse
' Calcul de la longueur de l'enregistrement
RecLength = Len(UneAdresse)
' Récupérer le premier numéro de fichier libre.
FileNum = FreeFile ' Ouvrir le fichier.
FileOpen(FileNum, "", OpenMode.Random, , , RecLength)
Pour écrire des données sur le second enregistrement par exemple :
= "Philippe"
= "Grande rue"
UneAdresse.Ville = "Lyon" FilePut(FileNum, UneAdresse,2 )
Dans cette ligne de code, FileNum contient le numéro utilisé par la fonction FileOpen pour ouvrir le fichier, 2 est le numéro de l'enregistrement ou sera copié la variable 'UneAdresse' (c'est un long si on utilise une variable) et UneAdresse, déclaré en tant que type Adresse défini par l'utilisateur, reçoit le contenu de l'enregistrement. Cela écrase l'enregistrement 2 s'il contenait quelque chose.
Pour écrire à la fin du fichier, ajouter un enregistrement il faut connaître le nombre d'enregistrement et écrire l'enregistrement suivant.
Dim last as long 'noter que le numéro d'enregistrement est un long
Pour connaître le nombre d'enregistrement, il faut diviser la longueur du fichier par la longueur d'un enregistrement.
last = FileLen("") / RecLength On ajoute 1 pour créer un nouvel enregistrement.
FilePut(FileNum, UneAdresse,last+1 )
Pour lire un enregistrement (le premier par exemple) :
FileGet(FileNum, UneAdresse, 1)
Attention Option Strict doit être à false.
Si option Strict est à True, la ligne qui précède génère une erreur car le second argument attendu ne peut pas être une variable 'structure'. Pour que le second argument de FileGet (Une adresse) soit converti dans une variable Structure automatiquement Option Strict doit donc être à false. (Il doit bien y avoir un moyen de travailler avec Option Strict On et de convertir explicitement mais je ne l'ai pas trouvé)
Remarque : si le fichier contient 4 enregistrements, on peut écrire le 10ème enregistrement, VB ajoute entre le 4ème et le 10ème, 5 enregistrements vides. On peut lire un enregistrement qui n'existe pas, cela ne déclenche pas d'erreur.
Le numéro d'enregistrement peut être omis dans ce cas c'est l'enregistrement courant qui est utilisé.
On positionne l'enregistrement courant avec Seek :
Exemple, lire le 8ème enregistrement : Seek(FileNum,8)
FileGet(FileNum,Une Adresse)
Suppression d'enregistrements
Vous pouvez supprimer le contenu d'un enregistrement en effaçant ses champs (enregistrer à la même position des variables vides), mais l'enregistrement existe toujours dans le fichier.
Pour enlever un enregistrement supprimé
1. Créez un nouveau fichier.
2. Copiez tous les enregistrements valides du fichier d'origine dans le nouveau fichier (pas ceux qui sont vide).
3. Fermez le fichier d'origine et utilisez la fonction Kill pour le supprimer.
4. Utilisez la fonction Rename pour renommer le nouveau fichier en lui attribuant le nom du fichier d'origine.
3-Fichier binaire
Dans les fichiers binaires on travaille sur les octets.
La syntaxe est la même que pour les fichiers Random, sauf qu'on travaille sur la position d'un octet et non sur un numéro d'enregistrement.
Pour ouvrir un fichier binaire :
FileOpen(FileNumber, FileName, OpenMode.Binary)
FileGet et FilePut permettent de lire ou d'écrire des octets.
FileOpen(iFr, ReadString, OpenMode.Binary)
MyString = New String(" "c, 15) 'Créer une chaîne de 15 espaces
FileGet(iFr, MyString) ' Lire 15 caractères dans MyString
FileClose(iFr) MsgBox(MyString)
Le fait de créer une variable de 15 caractères et de l'utiliser dans FileGet permet de lire 15 caractères.
On rappelle que du texte présent dans un contrôle RichTextBox peut être enregistré ou lu très simplement avec les méthodes .SaveFile et .LoadFile.
Le texte peut être du texte brut ou du RTF.
richTextBox1.SaveFile(FileName, RichTextBoxStreamType.PlainText)
Si on remplace.PlainText par .RichText c’est le texte enrichi et non le texte brut qui est enregistré.
Pour lire un fichier il faut employer .LoadFile avec la même syntaxe. Simple, non!!!
BinaryWriter et BinaryReader permettent d'écrire ou de lire des données binaires. XMLTextWriter et XMLTextReader écrit et lit du Xml.
Comment créer, copier effacer des répertoires (ou dossiers) ?
Pour travailler sur les dossiers (ou répertoires), il faut au préalable taper :
Imports
La classe Directory est utilisée pour travailler sur un ensemble de dossier, la Classe directoryInfo donne des renseignements sur un dossier particulier (Après instanciation).
La Classe Directory possède les méthodes suivantes :
- Exists Teste si le dossier existe.
- CreateDirectory Crée le dossier
- Delete Efface le dossier
- Move Déplacement de dossier
- GetCurrentDirectory Retourne le dossier de travail de l'application en cours - SetCurrentDirectory Définit le dossier de travail de l'application.
- GetDirectoryRoot Retourne le dossier racine du chemin spécifié.
- GetDirectories Retourne le tableau des sous dossiers du dossier spécifié.
- GetFiles Retourne les fichiers du dossier spécifié.
- GetFilesSystemEntries Retourne fichier et sous dossier avec possibilité d'un filtre.
- GetLogicalDrives Retourne les disques - GetParent Retourne le dossier parent du dossier spécifié.
La Classe Directory est statique, on l'utilise directement.
Exemple:
Afficher dans une listeBox les sous dossiers du répertoire de l'application :
Dim SousDos() As String= Directory.GetDirectories(Directory.GetCurrentDirectory)
Dim Dossier As String
For Each Dossier In SousDos (Dossier)
Next
La Classe DirectoryInfo possède les propriétés suivantes :
Name Nom du dossier (sans extension)
Full Name Chemin et nom du dossier
Exists
Parents Dossier parent Root Racine du dossier
La Classe DirectoryInfo n'est pas statique, il faut instancer un dossier avant de l'utiliser.
Il y a aussi les méthodes suivantes :
Create, Delete, MoveTo CreateSubdirectory
GetDirectories Retourne les sous dossier
GetFiles Retourne des fichiers
GetFileSystemInfos
Exemple :
Afficher le répertoire parent d'un dossier : Dim D As DirectoryInfo
D= New DirectoryInfo( MonDossier)
MsgBox(D.Parent.ToString)
La Classe statique Path a des méthodes simplifiant la manipulation des répertoires.
Exemple :
Si C= "C:\Windows\"
Path.GetDirectoryName(C) retourne "C:\Windows
Path.GetFileName(C) retourne ""
Path.GetExtension(C) retourne ".txt"
Path.GetFileNameWithoutExtension(C) retourne "MonFichier"
Path.PathRoot(C) retourne "c:\"
Il y a aussi les méthodes ChangeExtension, Combine, HasExtension
Fournit des informations concernant l'environnement et la plate-forme en cours ainsi que des moyens pour les manipuler.
Par exemple, les arguments de la ligne de commande, le code de sortie, les paramètres des variables d'environnement, le contenu de la pile des appels, le temps écoulé depuis le dernier démarrage du système ou le numéro de version du Common Language Runtime mais aussi certains répertoires.
Environment.CurrentDirectory 'donne le répertoire courant : ou le processus en cours démarre.
Environment.MachineName 'Obtient le nom NetBIOS de l'ordinateur local. Environment.OsVersion 'Obtient un objet contenant l'identificateur et le numéro de version de la plate-forme en cours.
Environment.SystemDirectory 'Obtient le chemin qualifié complet du répertoire du système
Environment.UserName 'Obtient le nom d'utilisateur de la personne qui a lancé le thread en cours.
La fonction GetFolderPath avec un argument faisant partie de l'énumération SpecialFolder retourne le répertoire d'un tas de choses :
Exemples :
Quel est le répertoire Système ?
Environment.GetFolderPath(Environment.SpecialFolder.System)
Comment récupérer le nom des disques ?
Dim drives As String() = Environment.GetLogicalDrives()
Comment récupérer la ligne de commande ?
Dim arguments As String() = Environment.GetCommandLineArgs()
CurDir()
Retourne le chemin d'accès en cours.
MyPath = CurDir()
MyPath = CurDir("C"c)
Dir()
Retourne une chaîne représentant le nom d'un fichier, d'un répertoire ou d'un dossier qui correspond à un modèle ou un attribut de fichier spécifié ou à l'étiquette de volume d'un lecteur.
'Vérifier si un fichier existe :
'Retourne "" si il existe.
MyFile = Dir("C:\WINDOWS\")
'Retourne le fichier spécifié par l'extension.
MyFile = Dir("C:\WINDOWS\*.INI")
'Un nouveau Dir retourne le fichier suivant
MyFile = Dir()
'On peut surcharger avec un attribut qui sert de filtre. MyFile = Dir("*.TXT", vbHidden) ' affiche les fichiers cachés
'Recherche les sous répertoires.
MyPath = "c:\" ' Set the path. MyName = Dir(MyPath, vbDirectory)
ChDrive
Change le lecteur actif. La fonction lève une exception si le lecteur n'existe pas.
ChDrive("D")
MkDir
Créé un répertoire ou un dossier. Si aucun lecteur n'est spécifié, le nouveau répertoire ou dossier est créé sur le lecteur actif.
MkDir("C:\MYDIR")
RmDir
Enleve un répertoire ou un dossier existant.
'Vérifier que le répertoire est vide sinon effacez les fichiers avec Kill.
RmDir ("MYDIR")
ChDir
Change le répertoire par défaut mais pas le lecteur par défaut.
ChDir("D:\TMP")
L'exécution de changements relatifs de répertoire s'effectue à l'aide de "..", comme suit : ChDir("..") 'Remonte au répertoire parent.
FileCopy
Copier un fichier.
FileCopy(SourceFile, DestinationFile)
Rename
Renommer un fichier, un répertoire ou un dossier.
Rename (OldName, NewName)
FileLen
Donne la longueur du fichier, SetAttr et GetAttr modifie ou lit les attributs du fichier Result = GetAttr(FName)
Result est une combinaison des attributs. Pour déterminer les attributs définis, utilisez l'opérateur And pour effectuer une comparaison d'opérations de bits entre la valeur retournée par la fonction GetAttr et la valeur de l'attribut. Si le résultat est différent de zéro, cet attribut est défini pour le fichier désigné.
Par exemple, la valeur de retour de l'expression And suivante est zéro si l'attribut Archive n'est pas défini :
Result = GetAttr(FName) And vbArchive
Comment afficher du texte, du numérique suivant le format désiré ?
On a vu que pour afficher du texte il fallait l'affecter à la propriété 'text' d'un label ou d'un textBox (ou pour des tests l'afficher sur la fenêtre 'console').
Pas de problème pour afficher des chaînes de caractères, par contre, pour les valeurs numériques, il faut d'abord les transformer en String' et les formater (définir les séparateurs, le nombre de décimales ).
On a déjà vu que pour afficher une variable numérique, il fallait la transformer en string de la manière suivant :
MyDouble.ToString
Mais ToString peut être surchargé par un paramètre appelé chaîne de format. Cette chaîne de format peut être standard ou personnalisée. • Chaîne de format standard :
Cette chaîne est de la forme 'Axx' ou A donne le type de format et xx le nombre de chiffre après la virgule.
Imports System
Imports System.Globalization Imports System.Threading
Module Module1 Sub Main()
Thread.CurrentThread.CurrentCulture = New CultureInfo("en-us")
Dim UnDouble As Double = 123456789
Console.WriteLine("Cet exemple est en-US culture:")
Console.WriteLine(UnDouble.ToString("C")) 'format monétaire (C) affiche
$123,456,789.00
Console.WriteLine(UnDouble.ToString("E")) 'format scientifique (E) affiche
1.234568E+008
Console.WriteLine(UnDouble.ToString("P")) 'format % (P) affiche
12,345,678,900.00%
Console.WriteLine(UnDouble.ToString("N")) 'format nombre (N) affiche
123,456,789.00
Console.WriteLine(UnDouble.ToString("F")) 'format virgule fixe (F) affiche
123456789.00
End Sub
End Module
Autre exemple :
S=(1.2).ToString("C") ‘retourne en CurrentCulture Français 1,2€
Il existe aussi D pour décimal, G pour général X pour hexadécimal.
• Chaîne de format personnalisé :
On peut créer de toute pièce un format, on utilise pour cela :
0 indique une espace réservé de 0
Chaque '0' est réservé à un chiffre. Affiche un chiffre ou un zéro. Si le nombre contient moins de chiffres que de zéros, affiche des zéros non significatifs.
Si le nombre contient davantage de chiffres à droite du séparateur décimal qu'il n'y a de zéros à droite du séparateur décimal dans l'expression de format, arrondit le nombre à autant de positions décimales qu'il y a de zéros.
Si le nombre contient davantage de chiffres à gauche du séparateur décimal qu'il n'y a de zéros à gauche du séparateur décimal dans l'expression de format, affiche les chiffres supplémentaires sans modification. # indique un espace réservé de chiffre.
Chaque '#' est réservé à un chiffre. Affiche un chiffre ou rien. Affiche un chiffre si l'expression a un chiffre dans la position où le caractère # apparaît dans la chaîne de format, sinon, n'affiche rien dans cette position.
Ce symbole fonctionne comme l'espace réservé au 0, sauf que les zéros non significatifs et à droite ne s'affichent pas si le nombre contient moins de chiffres qu'il n'y a de caractères # de part et d'autre du séparateur décimal dans l'expression de format.
. (point) indique l'emplacement du séparateur décimal (celui affiché sera celui du pays ) Vous devriez donc utiliser le point comme espace réservé à la décimale, même si vos paramètres régionaux utilisent la virgule à cette fin. La chaîne mise en forme apparaîtra dans le format correct pour les paramètres régionaux.
, (virgule) indique l'emplacement du séparateur de millier.
Séparateur de milliers. Il sépare les milliers des centaines dans un nombre de quatre chiffres ou plus à gauche du séparateur décimal. "Littéral" la chaîne sera affichée telle quelle.
% affichera en pour cent.
Multiplie l'expression par 100. Le caractère du pourcentage (%) est inséré
E0 affiche en notation scientifique. : et / sont séparateur d'heure et de date.
; est le séparateur de section : on peut donner 3 formats (un pour les positifs, un pour les négatifs, un pour zéro) séparés par ;
Exemples :
Chaîne de format '0000', le chiffre 145 cela affiche '0145'
Chaîne de format '####', le chiffre 145 cela affiche '145'
Chaîne de format '000.00', le chiffre 45.2 cela affiche '045.20'
Chaîne de format '#,#', le chiffre 12345678 cela affiche '12,345,678'
Chaîne de format '#,,' le chiffre 12345678 cela affiche '12'
La chaîne de formatage' #,##0.00 ' veut dire obligatoirement 2 chiffres après le séparateur décimal et un avant :
Si on affiche avec ce format
1.1 cela donne 1,10
.5 cela donne 0,50
4563 cela donne 4 563,00
Exemples :
Dim N As Double = 19.95
Dim MyString As String = N.ToString("$#,##0.00;($#,##0.00);Zero")
' En page U.S. English culture, MyString aura la valeur: $19.95.
' En page Française, MyString aura la valeur: 19,95€.
Exemples :
Dim UnEntier As Integer = 42
MyString = UnEntier.ToString( "Mon nombre " + + "= #" )
Affiche :
Mon nombre
= 42
Il permet de transformer une variable numérique et String, qui peut ensuite être affichée.
MyString=Str(LeNombre) =MyString
Pas de formattage…
Permet de combiner des informations littérales à afficher sans modification et des zones formatées.
Les arguments de String.Format se décomposent en 2 parties séparées d'une virgule.
- Chaîne de formatage entre guillemets : Exemple "{0} + {1} = {2}": les numéros indique l'ordre des valeurs.
- Valeurs à afficher dans l'ordre, la première étant d'indice zéro. Exemple= A, B, A+B
Exemple :
Si A=3 et B=5
MsgBox(String.Format("{0} + {1} = {2}",A, B, A+B)) affiche 3+5=8
Autre exemple :
Dim MonNom As String = "Phil"
String.Format("Nom = {0}, heure = {hh}", MonNom, )
Le texte fixe est « Nom = » et « ", heure = », les éléments de format sont « {0} » et « {hh} » et la liste de valeurs est MonNom et .
Cela affiche : Nom = Phil Heure= 10Là aussi on peut utiliser les formats :
• Prédéfinis: Ils utilisent là aussi les paramètres régionaux. Ils utilisent C, D, E, F, G, N, P, R, X comme ToSting.
|
MsgBox(String.Format("{0:C}",-456.45)) |
‘Affiche -456,45€ |
|
MsgBox(String.Format("{0:D8}", 456)) |
‘Affiche 00000456 Décimal 8 chiffres |
|
MsgBox(String.Format("{0:P}", 0.14)) |
‘Affiche 14% Pourcent |
|
MsgBox(String.Format("{0:X}", 65535)) |
‘Affiche FFFF Hexadécimal |
• Personnalisé: avec des # et des 0
MsgBox(String.Format("{0:##,##0.00}", 6553.23))
La fonction Format (et pas la classe String.Format) fourni des fonctions similaires mais les arguments sont dans l'ordre inverse (valeur, chaîne de formatage) et il n'y a pas de numéro d'ordre et de{}!! C'est pratique pour afficher une seule valeur. MyStr = Format(5459.4, "##,##0.00") ' Returns "5,459.40". MyStr = Format(334.9, "###0.00") ' Returns "334.90". MyStr = Format(5, "0.00%") ' Returns "500.00%".
On se rend compte que l'affichage est dépendant de la CurrentCulture du Thread en cours.
Exemple :
Si la CurrentCulture est la CultureInfo Us et que j'affiche avec le format 'C' (monétaire) cela affiche un $ avant, si je suis en CurrentCulture Français cela affiche un € après.
Par défaut la CultureInfo est celle définie dans Windows.
On peut modifier le CurrentCulture par code (voir exemple plus haut).
En français par défaut :
Le séparateur de décimal numérique est le .
Exemple : 1.20
Le séparateur décimal monétaire est la ,
Exemple : 1,20€
Comment modifier l'apparence du curseur ?
Un curseur est une petite image dont l'emplacement à l'écran est contrôlé par la souris, un stylet ou un trackball. Quand l'utilisateur déplace la souris, le système d'exploitation déplace le curseur.
Différentes formes de curseur sont utilisées pour informer l'utilisateur de l'action que va avoir la souris.
Pour modifier l'aspect du curseur il faut modifier l'objet Cursor.Current; l'énumération Cursors contient les différents curseurs disponibles :
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor
Ou plus simplement pour afficher le sablier :
Cursor.Current = Cursors.WaitCursor
Pour revenir au curseur normal :
Cursor.Current = Cursors.Défault Comme d'habitude il suffit de taper « Cursors. » pour voir la liste des curseurs.
Le curseur peut disparaître et être de nouveau affiché par Hide et Show.
Un contrôle dans une fenêtre possède une propriété Cursor; en mode design, si je donne une valeur autre que celle par défaut, CursorWait par exemple, cela modifie le curseur quand la souris passe au dessus de l'objet (met un sablier dans notre exemple).
Comment lancer une autre application ?
Shell lance un programme exécutable.
Id=Shell (NomdeProgramme) 'lance l'application NomdeProgramme
on peut aussi utiliser :
Id=Shell(NomdeProgramme, TypedeFenetre, Wait, TimeOut)
TypedeFenêtre utilise l'énumération AppWinStyle pour définir le type de fenêtre de l'application lancé, AppWinStyle.MaximizedFocus ouvre par exemple l'application en plein écran.
Si vous souhaitez attendre la fin du programme avant de continuer, vous devez définir Wait à True.
TimeOut est le nombre de millisecondes à attendre pour la fin du programme si Wait est True.
Exemple :
ID = Shell("""C:\Program Files\"" -a -q", , True, 100000)
Dans une chaîne une paire de guillemets doubles adjacents ("") est interprétée comme un caractère de guillemet double dans la chaîne. Ainsi, l'exemple précédent présente la chaîne suivante à la fonction Shell :
"C:\Program Files\" -a -q
La fonction AppActivate rend active l'application ou la fenêtre définie par son nom ou son Id. Dim ID As Integer
On peut utiliser :
AppActivate("Untitled - Notepad") ou
ID = Shell(", AppWinStyle.MinimizedNoFocus) AppActivate(ID)
La Classe Process fournit l'accès à des processus locaux ainsi que distants, et vous permet de démarrer et d'arrêter des processus système locaux.
Classe de nom à importer : Imports System.Diagnostics
On peut maintenant instancer un Process.
Dim monProcess As New Process()
Ensuite il faut fournir à la classe fille StartInfo les informations nécessaires au démarrage.
monProcess.StartInfo.FileName = "" = "Print" monProcess.StartInfo.CreateNoWindow = True
Enfin on lance le process :
monProcess.Start()
Noter la puissance de cette classe : on donne le nom du document et VB lance l'exécutable correspondant, on fait effectuer certaines action au programme.
Dans l'exemple du dessus on ouvre Word on y charge MyFile, on l'imprime, cela sans ouvrir de fenêtre.
On peut aussi utiliser la classe Process en statique (sans instanciation)
Process.Start("") Process.Start(MonPathFavori)
Ou en une ligne :
Process.Start("", "")
En local on peut afficher un fichier html ou asp :
Process.Start("", "C:\monPath\") Process.Start("", "C:\monPath\")
On peut enfin utiliser un objet StartInfo :
Dim startInfo As New ProcessStartInfo("") startInfo.WindowStyle = ProcessWindowStyle.Minimized Process.Start(startInfo)
startInfo.Arguments =
Process.Start(startInfo)
Des propriétés du processus en cours permettent de connaître l'Id du processus (Id) les threads, les modules, les Dll, la mémoire, de connaître le texte de la barre de titre (MainWindowsTitle)…
On peut fermer le processus par Close ou CloseMainWindows
On peut instancer un processus sur une application déjà en cours avec GetProcessByName et GetProcessById :
Dim P As Process() = Process.GetProcessesByName("notepad")
On peut récupérer le processus courant :
Dim ProcessusCourant As Process = Process.GetCurrentProcess()
Récupérer toutes les instances de Notepad qui tourne en local :
Dim localByName As Process() = Process.GetProcessesByName("notepad")
Récupérer tous les processus en cours d'exécution grâce à GetProcesses : Dim localAll As Process() = Process.GetProcesses()
Processus sur ordinateur distant.
Vous pouvez afficher des données statistiques et des informations sur les processus en cours d'exécution sur des ordinateurs distants, mais vous ne pouvez pas appeler Kill, Start, CloseMainWindows sur ceux-ci.
Comment Imprimer ?
Prévoir une longue soirée, au calme, un bon siège, 1 g de paracétamol et un gros thermo de café !!!
On devra que l'on peut utiliser pour imprimer :
Soit un composant 'PrintDocument'.
Soit une instance de 'la Class PrintDocument'.
A-Imprimer ‘Hello’ avec le composant ‘PrintDocument’.
L'utilisateur clique sur un bouton, cela imprime 'Hello' Cet exemple utilise un 'composant PrintDocument'
Comment faire en théorie? C'est le composant PrintDocument qui imprime.
En prendre un dans la boite à outils, le mettre dans un formulaire. Il apparaît sous le formulaire et se nomme PrintDocument1.
Pour imprimer il faut utiliser la méthode Print de ce composant PrintDocument, Il faut donc écrire l'instruction suivante :
PrintDocument1.Print
Cette instruction appelle la procédure évènement PrintDocument1_PrintPage du composant PrintDocument et qui contient la logique d'impression. Un paramètre de cet évènement PrintPage est l'objet graphique envoyé à l'imprimante. C'est à vous de dessiner dans l'objet graphique ce que vous voulez imprimer. En fin de routine, l'objet graphique sera imprimé (automatiquement).
En pratique :
- Je prends un PrintDocument dans la boite à outils, je le mets dans un formulaire. Il apparaît sous le formulaire et se nomme PrintDocument1.
- Si je double-clique sur PrintDocument1 je vois apparaître la procédure PrintDocument1_PrintPage (qui a été générée automatiquement) :
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage End Sub
C'est cette procédure qui est fondamentale et qui contient les routines d'impression écrites par le programmeur. Les routines d'impression agissent sur l'objet graphique qui sera utilisé pour imprimer, cet objet graphique est fournit dans les paramètres de la procédure(ici c'est e qui est de type PrintPageEventArgs)
- Dans cette routine PrintPage, j'ajoute donc le code dessinant une texte (DrawString)
sur l'objet graphique 'e':
e.Graphics.DrawString("Hello", New Font("Arial", 80, ), Brushes.Black, 150, 125)
- Enfin je dessine un bouton nommé 'ButtonPrint' avec une propriété Text contenant
"Imprimer Hello" et dans la procédure ButtonPrint_Click j'appelle la méthode Print PrintDocument1.Print()
Voici le code complet:
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, ByVal e As
System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage
e.Graphics.DrawString("Hello", New Font("Arial", 80, ), Brushes.Black, 150, 125)
End Sub
Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles ButtonPrint.Click
PrintDocument1.Print()
End Sub
Si je clique sur le bouton 'ImprimerHello' cela affiche un gros 'Hello'.
La méthode Print d'un PrintDocument déclenche l'évènement PrintPage de ce PrintDocument qui contient le code dessinant sur le graphique de la page à imprimer. En fin de routine PrintPage le graphique est imprimer sur la feuille de l'imprimante.
Toutes les méthodes graphiques permettant d'écrire, de dessiner, de tracer des lignes sur un graphique permettent donc d'imprimer.
Créons une ellipse bleue à l'intérieur d'un rectangle avec la position et les dimensions suivantes : début à 100, 150 avec une largeur de 250 et une hauteur de 250.
Private Sub PrintDocument1_PrintPage(ByVal sender As Object, ByVal e As
System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage
e.Graphics.FillEllipse(, New Rectangle(100, 150, 250, 250)) End Sub
Imprimer un Message Box indiquant ‘Fin d’impression’.
On a étudié l'évènement PrintPage, mais il existe aussi les évènements : BeginPrint et EndPrint respectivement déclenchés en début et fin d'impression
Il suffit d'utiliser l'évènement EndPrint pour prévenir que l'impression est terminée: Private Sub PrintDocument1_EndPrint(ByVal sender As Object, ByVal e As
System.Drawing.Printing.PrintEventArgs) Handles PrintDocument1.EndPrint ("Fin d'impression")
End Sub
On peut même fignoler et afficher "Fin d'impression de Nom du document" Il faut avoir renseigné le DocumentName:
PrintDocument1.DocumentName = "MyTextFile"
Puis écrire :
Private Sub PrintDocument1_EndPrint(ByVal sender As Object, ByVal e As
System.Drawing.Printing.PrintEventArgs) Handles PrintDocument1.EndPrint ( "Fin d'impression de "+PrintDocument1.DocumentName) End Sub
L'utilisateur clique sur un bouton, cela imprime 'Hello'
Cet exemple utilise 'une instance de la Class PrintDocument'. On ne met pas de composant 'PritDocument' dans le formulaire.
Comment faire en théorie?
Il faut importer l'espace de nom 'Printing' par :
Imports System.Drawing.Printing
Il faut créez une instance de la Class PrintDocument dans le module.
Dim pd as PrintDocument = new PrintDocument()
Il faut créer une routine pd_PrintPage.
Private Sub pd_PrintPage(sender As object, ev As
System.Drawing.Printing.PrintPageEventArgs)
End sub
Il faut indiquer le "lien" entre l'objet pd et la routine évènement PrintPage
AddHandler pd.PrintPage, AddressOf Me.pd_PrintPage
Dans la procédure Button_Click d'un bouton "Imprimer" il faut appeler la méthode Print du PrintDocument pour effectuer l'impression du document.
pd.Print
Cela déclenche la procédure Private Sub pd_PrintPage précédemment écrite, dans laquelle on a ajouté :
ev.Graphics.DrawString ("Hello", printFont, Brushes.Black, leftMargin, yPos, new StringFormat()).
Cela donne le code complet:
Imports System.Drawing.Printing
Public Class Form1
Inherits
Dim pd As PrintDocument = New PrintDocument 'Assumes the default printer
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles
AddHandler pd.PrintPage, AddressOf Me.Pd_PrintPage
Private Sub Pd_PrintPage(ByVal sender As System.Object, ByVal e As
System.Drawing.Printing.PrintPageEventArgs)
e.Graphics.DrawString("Hello", New Font("Arial", 80, ), Brushes.Black, 150, 125) End Sub
Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles ButtonPrint.Click pd.Print()
End Class
Comment choisir l’imprimante ?
Le composant PrintDialog permet le choix de l'imprimante, de la zone à imprimer (tout, la sélection..) et donne accès aux caractéristiques de l'imprimante.
Comment l'utiliser ?
Il faut créer une instance de PrintDialog:
Dim dlg As New PrintDialog
Il faut indiquer au PrintDialog sur quel PrintDocument travailler :
dlg.Document = pd
Puis ouvrir la fenêtre PrintDialog avec la méthode ShowDialog.
L'utilisateur choisit son imprimante puis clique sur 'Ok'. Si elle retourne Ok, on imprime.
Voici le code complet ou quand l'utilisateur clique sur le bouton ButtonPrint ('Imprimer') la fenêtre PrintDialog s'ouvre :
Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonPrint.Click
Dim dlg As New PrintDialog dlg.Document = pd
Dim result As DialogResult = dlg.ShowDialog()
If (result = ) Then pd.Print()
End If
End Sub
Comment modifier la page à imprimer ? Comment choisir d'imprimer en portrait ou paysage ? Modifier les marges...
Il faut utiliser un composant PageSetUpDialog.
Pour stocker les informations sur la page (marges ) il faut un PageSetting
Je lie le PageSetting au PageSetUpDialog en donnant à la propriété PageSettings du PageSetUpDialog le nom du PageSetting. Puis j'ouvre le PageSetUpDialog.
Au retour le PageSetting contient les modifications, je les 'passe' au PrintDocument avant d'imprimer.
Cela donne :
Dim psDlg As New PageSetupDialog Dim LePageSettings As New PageSettings psDlg. PageSettings = LePageSettings psDlg.ShowDialog()
pd.DefaultPageSettings = LePageSettings
On utilise pour cela un PrintPreviewDialog, on lui indique quel PrintDocument pré visualiser en l'assignant à sa méthode document puis on l'affiche par ShowDialog(). Dim dllg As New PrintPreviewDialog dllg.Document = pd dllg.ShowDialog()
Construction d’une application d’impression complexe Comment imprimer le contenu d'un fichier texte vers une imprimante ?
Tous les didacticiels (Microsoft compris) donnent cet exemple.
La première chose que vous devez faire est d'écrire votre logique d'impression. Pour cela, quand la méthode PrintDocument.Print() est appelée, les événements suivants sont déclenchés.
- BeginPrint
- PagePrint (un ou plusieurs s'il y a plusieurs pages à imprimer)
- EndPrint
Le type d'arguments d'événement de PagePrint (PagePrintEventArgs) comprend une propriété HasMorePages. Si celle-ci a la valeur TRUE lors du retour de votre gestionnaire d'événements, PrintDocument définit une nouvelle page et déclenche de nouveau l'événement PagePrint.
Voyons la logique dans votre gestionnaire d'événements PagePrint :
- Imprimez le contenu de la page en utilisant les informations des arguments d'événement. Les arguments d'événement contiennent l'objet Graphics pour l'imprimante, le PageSettings pour cette page, les limites de la page, et la taille des marges.
Il faut dans PagePrint imprimer ligne par ligne en se déplaçant à chaque fois vers le bas d'une hauteur de ligne.
Pour 'simplifier', on considère que chaque ligne ne déborde pas à droite!!
- Détermine s'il reste des pages à imprimer.
- Si c'est le cas, HasMorePages doit être égal à TRUE. - S'il n'y a pas d'autres pages, HasMorePages doit être égal à FALSE.
Public Class ExampleImpression
Inherits
private printFont As Font
private streamToPrint As StreamReader
Public Sub New ()
InitializeComponent()
End Sub
'Evénement survenant lorsque l'utilisateur cloque sur le bouton 'imprimer'
Private Sub printButton_Click(sender As object, e As System.EventArgs)
Try
streamToPrint = new StreamReader ("")
Try
printFont = new Font("Arial", 10)
Dim pd as PrintDocument = new PrintDocument() 'déclaration
du PrintDocument
AddHandler pd.PrintPage, AddressOf Me.pd_PrintPage pd.Print()
Finally
streamToPrint.Close()
End Try
Catch ex As Exception
("Une erreur est survenue: - " + ex.Message) End Try
End Sub
'Evènement survenant pour chaque page imprimer Private Sub pd_PrintPage(sender As object, ev As
System.Drawing.Printing.PrintPageEventArgs)
Dim lpp As Single = 0 'nombre de ligne par page
Dim yPos As Single = 0 'ordonnée
Dim count As Integer = 0 'numéro de ligne
Dim leftMargin As Single = Dim topMargin As Single =
Dim line as String
'calcul le nombre de ligne par page
' hauteur de la page/hauteur de la police de caractère
lpp = ev.MarginBounds.Height / printFont.GetHeight(ev.Graphics)
'lit une ligne dans le fichier line=streamToPrint.ReadLine()
'Boucle affichant chaque ligne
yPos = topMargin + (count * printFont.GetHeight(ev.Graphics))
'Ecrit le texte dans l'objet graphique
ev.Graphics.DrawString (line, printFont, Brushes.Black, leftMargin, _ yPos, new StringFormat())
count = count + 1
if (count < lpp) then line=streamToPrint.ReadLine() end if
'S'il y a encore des lignes, on réimprime une page
If (line <> Nothing) Then ev.HasMorePages = True Else ev.HasMorePages = False
End If
End Sub
.
End Class
On a vu que pour 'simplifier', on considère que chaque ligne ne déborde pas à droite.
Dans la pratique, pour gérer les retours à la ligne on peut dessiner dans un rectangle. (Voir la page sur les graphiques.)
On peut sans passer par une 'boite de dialog' gérer directement l'imprimante, les marges, le nombre de copies…
Si pd est le PrintDocument :
pd.PrinterSetting désigne l'imprimante en cours pd.PrinterSetting.PrinterName retourne ou définit le nom de cette imprimante pd.PrinterSetting.Printerresolution donne la résolution de cette imprimante. pd.PrinterSetting.installedPrinted donne toutes les imprimantes installées.
La propriété DefaultPageSetting est en rapport avec les caractéristiques de la page. pd.PrinterSetting.DefaultPageSetting.Margins donne les marges
pd.PrinterSetting.PrinttoFile permettrait d'imprimer dans un fichier (non testé)
Exemple fournit par Microsoft :
Private Declare Function BitBlt Lib "" Alias "BitBlt" (ByVal _ hdcDest As IntPtr, ByVal nXDest As Integer, ByVal nYDest As _ Integer, ByVal nWidth As Integer, ByVal nHeight As Integer, ByVal _ hdcSrc As IntPtr, ByVal nXSrc As Integer, ByVal nYSrc As Integer, _ ByVal dwRop As System.Int32) As Long
Dim memoryImage As Bitmap
Private Sub CaptureScreen()
Dim mygraphics As Graphics = Me.CreateGraphics() Dim s As Size =
memoryImage = New Bitmap(s.Width, s.Height, mygraphics)
Dim memoryGraphics As Graphics = Graphics.FromImage(memoryImage)
Dim dc1 As IntPtr = mygraphics.GetHdc
Dim dc2 As IntPtr = memoryGraphics.GetHdc
BitBlt(dc2, 0, 0, Me.ClientRectangle.Width, _
Me.ClientRectangle.Height, dc1, 0, 0, 13369376) mygraphics.ReleaseHdc(dc1) memoryGraphics.ReleaseHdc(dc2) End Sub
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, _ ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles _
PrintDocument1.PrintPage
e.Graphics.DrawImage(memoryImage, 0, 0)
End Sub
Private Sub PrintButton_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles PrintButton.Click
CaptureScreen()
PrintDocument1.Print()
End Sub
Imprime un contrôle DataGrid Exemple fournit par Microsoft :
Cet exemple nécessite :
- un contrôle Button, nommé ImprimerGrid, dans le formulaire ;
- un contrôle DataGrid nommé DataGrid1 ; - un composant PrintDocument nommé PrintDocument1. Comme d'habitude PrintPage imprime e.Graphics.
D'après ce que j'ai compris, l'évènement Paint redessine un contrôle mais on peut choisir le contrôle et l'endroit ou le redessiner,
Je redessine donc grâce à Paint, le DataGrid dans e.graphics.
PaintEventArgs Fournit les données pour l'événement Paint :
PaintEventArgs spécifie l'objet graphics à utiliser pour peindre le contrôle, ainsi que le ClipRectangle dans lequel le peindre.
InvokePaint déclenche l'évènement Paint
Private Sub ImprimerGrid_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles PrintGrid.Click
PrintDocument1.Print()
End Sub
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, _ ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles _
PrintDocument1.PrintPage
Dim myPaintArgs As New PaintEventArgs(e.Graphics, New Rectangle(New _ Point(0, 0), ))
Me.InvokePaint(DataGrid1, myPaintArgs)
End Sub
Avec GDI+ utilisé par , on utilise des objets :
Graphics qui sont des zones de dessin
Image (BitMap ou MetaFile) contenant une image
Rectangle pour définir une zone Pen correspondant à un Stylet
Font pour une police de caractères
Brush, c'est une brosse
Sur quoi dessiner ?
Il faut définir une zone de dessin, un objetGraphics. On peut y inclure des objets Image (des BitMap ou des MetaFile)
Pour obtenir un objet Graphics, il y a plusieurs façons :
- Soit on instance un objet Graphics. Dim g as Graphics 'Graphics contient Nothing, je ne peux rien en faire.
Il faut donc y mettre un objet Image (un BitMap ou un MetaFile) pour pouvoir travailler dessus.
Pour obtenir un BitMap par exemple, on peut :
Soit créer un objet BitMap vide :
Dim newBitmap As Bitmap = New Bitmap(600, 400) Dim g as Graphics = Graphics.FromImage(newBitmap)
Paramètres= taille du BitMap mais il y a plein de surcharges
Soit créer un BitMap à partir d'un fichier sur disque
C'est pratique si on veut modifier une image qui est dans un fichier: on la lit dans un BitMap puis on la passe dans l'objet Graphics.
Dim myBitmap as New Bitmap("") 'Charge maPhoto dans le BitMap
Dim g as Graphics = Graphics.FromImage(myBitmap) 'Crée un Graphics et y met le BitMap
g est un Graphics contenant l'image '' que je peux modifier.
Attention : le Graphics n'est pas 'visible', pour le voir il faut le mettre dans un composant (un PictureBox par exemple) qui lui sera visible. On verra cela plus bas.
- Soit on appelle la méthode CreateGraphics d'un contrôle ou d'un formulaire On appelle la méthodeCreateGraphics d'un contrôle ou d'un formulaire afin d'obtenir une référence à un objet Graphics représentant la surface de dessin de ce contrôle ou formulaire. Cette méthode est utilisée si vous voulez dessiner sur un formulaire ou un contrôle existant ; Dim g as Graphics g = Me.CreateGraphics 'Pour un formulaire Dim g as Graphics
g = Panel1.CreateGraphics 'Pour un contrôle Panel
On peut ensuite dessiner sur g, cela sera immédiatement visible. Il faut quand on n'utilise plus l'objet graphics, utiliser la méthode Dispose pour le libérer.
- Soit on récupère l'objet Graphics argument de l'évènement Paint d'uncontrôle.
L’événement Paint pour des contrôles se déclenche lorsque le contrôle est redessiné, un objet Graphics est fourni comme une valeur de PaintEventArgs.
Pour obtenir une référence à un objet Graphics à partir des PaintEventArgs de l'événement Paint
1. Déclarez l'objet Graphics
2. Assignez la variable pour qu'elle référence l'objet Graphics passé dans les PaintEventArgs.
3. Dessinez dans l'objet Graphics.
Private Sub Form1_Paint(sender As Object, pe As PaintEventArgs) Handles _ MyBase.Paint
Dim g As Graphics = pe. Graphics ' Dessiner dans pe ici
End Sub
Noter bien que pe est visible uniquement dans Form1_Paint
Pour déclencher l'évènement Paint et dessiner, on utilise la méthode OnPaint
Comment dessiner ?
La classe Graphics fournit des méthodes permettant de dessiner
DrawImage 'Ajoute une image (BitMap ou MetaFile)
DrawLine 'Trace une ligne
DrawString 'Ecrit un texte DrawPolygon 'Dessine un polygone
En GDI+ on envoie des paramètres à la méthode pour dessiner :
Exemple :
MonGraphique.DrawEllipse( New Pen(Couleur),r) 'cela dessine une ellipse Les 2 paramètres sont: la couleur et le rectangle dans lequel on dessine.
Pour travailler on utilise les objets :
|
Brush (Brosse) |
Utilisé pour remplir des surfaces fermées avec des motifs, des couleurs ou des bitmaps. Elles peuvent être pleine et ne contenir qu'une couleur. Dim SB= New SolidBrush() TextureBrush utilise une image pour remplir. Dim SB= New TextureBrush(MonImage) LinéarGradientBrush permet des dégradés (passage progressif d'une couleur à une autre). Dim SB= New LinearGradientBrush(PointDébut, PointFin,Color1, Color2) Les HatchBrush sont des brosses hachurées Dim HatchBrush hb = new HatchBrush(HatchStyle.ForwardDiagonal, Color.Green,Color.FromArgb(100, Color.Yellow)) Les PathGradient sont des brosses plus complexes. |
|
Pen (Stylet) |
Utilisé pour dessiner des lignes et des polygones, tels que des rectangles, des arcs et des secteurs. Comment créer un Stylet? Dim blackPen As New Pen(Color.Black) on donne la couleur Dim blackPen As New Pen(Color.Black, 3)on donne couleur et epaisseur Dim blackPen As New Pen(MyBrush) on peut même créer un stylet avec une brosse Propriétés de ce Stylet: DashStyle permet de faire des pointillés. StartCap et EndCap définissent la forme du début et de la fin du dessin (rond, carré, flèche ) |
|
Font (Police) |
Utilisé pour décrire la police utilisée pour afficher le texte. Dim Ft= New Font("Lucida sans unicode",60) 'paramètres=nom de font et taille Il y a de nombreuse surcharge. Dim Ft= New Font("Lucida sans unicode",60, )'pour écrire en gras |
|
Color (Couleur) |
Utilisé pour décrire la couleur utilisée pour afficher un objet particulier. Dans GDI+, la couleur peut être à contrôle alpha. pour le rouge |
|
Point |
Ils ont des cordonnées x, y Dim point1 As New Point(120, 120) ' avec des integer ou des PointF 'avec des Singles |
|
Rectangle |
Dim r As New RectangleF(0, 0, 100, 100) On remarque que le F après Point ou Rectangle veut dire 'Float', et necessite l'usage de Single. |
Comment faire ?Dessiner une ligne sur le graphique :
Pour dessiner une ligne, on utilise DrawLine.
Dim blackPen As New Pen(Color.Black, 3) 'créer un stylet noir d'épaisseur 3 ' Créer des points
Dim point1 As New Point(120, 120) 'créer des points
Dim point2 As New Point(600, 100)
' Dessine la ligne
e.Graphics.DrawLine(blackPen, point1, point2)
On aurait pu utiliser une surcharge de Drawline en spécifiant directement les coordonnées des points.
Dim x1 As Integer = 120
Dim y1 As Integer = 120
Dim x2 As Integer = 600 Dim y2 As Integer = 100
e.Graphics.DrawLine(blackPen, x1, y1, x2, y2)
Dessiner une ellipse :
Définir un rectangle dans lequel sera dessiné l'ellipse.
Dim r As New RectangleF(0, 0, 100, 100)
g.DrawEllipse(New Pen(), r)' Dessinons l' ellipse
Dessiner un rectangle :
myGraphics.DrawRectangle(myPen, 100, 50, 80, 40)
Comme d'habitude on peut fournir après le stylet des coordonnées(4), des points (2) ou un rectangle.
Dessiner un polygone :
Dim MyPen As New Pen(Color.Black, 3)
' Créons les points qui définissent le polygone
Dim point1 As New Point(150, 150)
Dim point2 As New Point(100, 25)
Dim point3 As New Point(200, 5)
Dim point4 As New Point(250, 50)
Dim point5 As New Point(300, 100)
Dim point6 As New Point(350, 200)
Dim point7 As New Point(250, 250)
Dim curvePoints As Point() = {point1, point2, point3, point4, _ point5, point6, point7} ' Dessinons le Polygone.
e.Graphics.DrawPolygon(MyPen, curvePoints
Dessiner un rectangle plein :
e.FillRectangle(new SolidBrush(), 300,15,50,50) Il existe aussi DrawArc, DrawCurve, DrawBezier DrawPie… Ecrire du texte sur le graphique :
Pour cela on utilise la méthode DrawString de l'objet graphique:
g.DrawString ("Salut", , New SolidBrush (ColorBlack), 10, 10)
Paramètres:
Texte à afficher.
Police de caractères
Brosse, cela permet d'écrire avec des textures. Coordonnées.
Si on spécifie un rectangle à la place des 2 derniers paramètres, le texte sera affiché dans le rectangle avec passage à la ligne si nécessaire :
Dim rectangle As New RectangleF (100, 100, 150, 150 )
Dim T as String= "Chaîne de caractères très longue"
g.DrawString (T, , New SolidBrush (ColorBlack), Rectangle)
On peut même imposer un format au texte :
Exemple, centrer le texte :
Dim Format As New StringFormat() Format.Aligment=StringAlignment.Center
g.DrawString (T, , New SolidBrush (ColorBlack), Rectangle, Format)
On peut mesurer la longueur (ou le nombre de lignes) d'une chaîne :
Avec MeasureString
Exemple, centrer le texte : pour cela, calculer la logeur de la chaine, puis calculer le milieu de l'écran moins la 1/2 longueur de la chaîne :
Dim W As Double= Me.DisplayRectangle.Width/2
Dim L As SizeF= e.Graphics.MeasurString (Texte, TextFont)
Dim StartPos As Double = W - (L.Width/2)
g.Graphics.MeasueString (T, , New SolidBrush (ColorBlack), Rectangle,
StartPos, 10)
Exemple, calculer le nombre de ligne et le nombre de caractères d'une chaîne :
g.Graphics.MeasueString (T, , New SolidBrush (ColorBlack), Rectangle,Nex
StringFormat() NombredeCaractères, NombredeLignes)
Ajouter une image sur le graphique :
Pour cela on utilise la méthode DrawImage de l'objet graphique :
g.Graphics.DrawImage(New Bitmap(""), 29, 20, 283, 212)
On peut travailler avec des images .jpeg .png .bmp .Gif .icon .tiff .exif
Charger une image
Si on veut afficher une image bitmap ou vectoriel, il faut fournir à l'objet Graphics un objet bitmap ou vectoriel. C'est la méthode DrawImage qui reçoit l'objet Metafile ou Bitmap comme argument. L'objet BitMap, si on le désire peut contenir le contenue d'un fichier qui sera affiché. Dim myBMP As New BitMap ("")
myGraphics.DrawImage(myBMP, 10, 10)
Le point de destination du coin supérieur gauche de l'image, (10, 10), est spécifié par les deuxième et troisième paramètres.
myGraphics.FromImage(myBMP) ’est aussi possible
On peut utiliser plusieurs formats de fichier graphique : BMP, GIF, JPEG, EXIF, PNG, TIFF et ICON.
Cloner une image
La classe Bitmap fournit une méthode Clone qui permet de créer une copie d'un objet existant. La méthode Clone admet comme paramètre un rectangle source qui vous permet de spécifier la portion de la Bitmap d'origine à copier. L'exemple suivant crée un objet Bitmap en clonant la moitié supérieure d'un objet Bitmap existant. Il dessine ensuite les deux images.
Dim originalBitmap As New Bitmap("")'on charge un fichier png dans un BitMap
Dim sourceRectangle As New Rectangle(0, 0, originalBitmap.Width, _ originalBitmap.Height / 2) 'on définit un rectangle
Dim secondBitmap As Bitmap = originalBitmap.Clone(sourceRectangle, _
PixelFormat.DontCare)'on définit un second BitMap Clonant une partie du 1ere BitMap avec le rectangle
'On met les 2 BitMap dans un Graphics myGraphics.DrawImage(originalBitmap, 10, 10) myGraphics.DrawImage(secondBitmap, 150, 10)
Enregistrer une image sur le disque On utilise pour cela la méthode Save.
Exemple: enregistrer le BitMap newBitMap dans '' ("", ) Comment voir un Graphics ?
Si on a instance un objet Graphics, on ne le voit pas. Pour le voir il faut le mettre dans un PictureBox par exemple:
Exemple :
Dim newBitmap As Bitmap = New Bitmap(200, 200) 'créons un BitMap
Dim g As Graphics = Graphics.FromImage(newBitmap)'créons un Graphics et y mettre le BitMap
Dim r As New RectangleF(0, 0, 100, 100)' Dessinons une ellipse g.DrawEllipse(New Pen(), r)
Comment voir l'ellipse ?
Ajoutons un PictureBox au projet, et donnons à la propriété Image de ce PictureBox le nom du BitMap du Graphics:
PictureBox1.Image = newBitmap
L'ellipse rouge apparaît!! Si, Si!!
Par défaut Paint n'est pas déclenché quand un contrôle ou formulaire est redimensionné, pour forcer à redessiner en cas de redimensionnement, il faut mettre le style Style.Resizedraw du formulaire ou du contrôle à true.
SetStyle (Style.Resizedraw, true)
Cette syntaxe marche, la suivante aussi (pour le formulaire) Me.SetStyle (Style.Resizedraw, true) 'pour tous les objets du formulaire?
Mais PictureBox1.SetStyle (Style.Resizedraw, true) n'est pas accepté!!
Afficher un texte en 3d.
PrivateSub TextEn3D(ByVal g As Graphics, ByVal position As PointF, ByVal text
AsString, ByVal ft As Font, ByVal c1 As Color, ByVal c2 As Color) Dim rect AsNew RectangleF(position, g.MeasureString(text, ft))
Dim bOmbre AsNew LinearGradientBrush(rect, Color.Black, , 90.0F)
g.DrawString(text, ft, bOmbre, position)
position.X -= 2.0F position.Y -= 6.0F
rect = New RectangleF(position, g.MeasureString(text, ft)) Dim bDegrade AsNew LinearGradientBrush(rect, c1, c2, 90.0F)
g.DrawString(text, ft, bDegrade, position) EndSub
Pour utiliser les graphiques il faut que System.Drawing soit importé (ce qui est fait par défaut).
(Systé comme références de l'assembly)
Quand l'utilisateur utilise votre logiciel, il est parfois en difficultés, comment l'aider? Avec des aides que le programmeur doit créer et ajouter au programme.
Généralités sur les 4 sortes d’aides La Class Help permet d'ouvrir un fichier d'aide.
Le composant HelpProvider offre 2 types d'aide.
- Le premier consiste à ouvrir un fichier d'aide grâce à F1 que l'utilisateur doit consulter.
- Quant au second, il peut afficher une aide brève pour chacun des contrôles en utilisant le bouton d'aide (?). Il s'avère particulièrement utile dans les boîtes de dialogue modal.
Le composant ToolTip offre lui :
- une aide propre à chaque contrôle des Windows Forms.
On peut utiliser les formats :
- HTML Fichier .htm
- HTMLHelp 1.x ou version ultérieure) Fichier .chm - HLP Fichier .hlp les plus anciens.
Comment créer ces fichiers :
Pour les fichiers HTM: Utiliser Word, ou FontPage, ou Netscape Composer
Pour les fichiers HLP:
Utiliser Microsoft HelpWorkshop livré avec VB6
Pour les fichiers CHM:
Thierry AIM fournit sur le site un excellent:
Cours pour créer un fichier CHM -
On conseille d'utiliser plutôt les fichiers chm.
Utilisation des fichiers d’aide !Appel direct : La classe Help permet d'ouvrir directement par code un fichier d'aide.
C'est ce qu'on utilise dans le menu '?' d'un programme (sous menu 'Aide'); dans la procédure correspondante (Sub Aide_Click) on écrit :
Help.ShowHelp (Me, "")
doit être dans le fichier de l'application (répertoire Bin) Cela peut être un URL, l'adresse d'une page sur Internet!!
Il peut y avoir un 3ème paramètres: on verra cela plus bas (C'est le même paramètre que la propriété HelpNagigator de HelpProvider).
Appel par la touche F1 :
Vous pouvez utiliser le composant HelpProvider pour attacher des rubriques d'aide figurant dans un fichier d'aide (au format HTML, HTMLHelp 1.x ou ultérieur) à des contrôles spécifiques.
Quand on met un composant dans un formulaire (avec dans la propriété HelpNamespace, le nom de fichier d'aide), cela ajoute aux contrôles de ce formulaire les propriétés :
- HelpNavigator qui détermine le type d'appel (par numéro de rubrique, mot clé…)
- HelpKeyword qui contient le paramètre de recherche (le numéro de rubrique, le mot clé…) Quand l'utilisateur est sur le contrôle et qu'il clique sur F1 la rubrique d'aide s'ouvre.
Pour créer cet aide :
Faites glisser un composant HelpProvider de la boîte à outils vers votre formulaire. Le composant se place dans la barre d'état située au bas de la fenêtre.
Dans la fenêtre Propriétés du HelpProvider , donner à la propriété HelpNamespace, un nom de fichier d'aide .chm, col ou .htm.
Dans la fenêtre Propriétés du contrôle qui déclenchera l'aide, donner à la propriété HelpNavigator une valeur de l'énumération HelpNavigator.
Cette valeur détermine la façon dont la propriété HelpKeyword est passée au système d'aide. HelpNagigator peut prendre la valeur :
|
AssociateIndex |
Indique que l'index d'une rubrique spécifiée est exécuté dans l'URL spécifiée. |
|
Find |
Indique que la page de recherche d'une URL spécifiée est affichée. |
|
Index |
Indique que l'index d'une URL spécifiée est affiché. |
|
KeywordIndex |
Spécifie un mot clé à rechercher et l'action à effectuer dans l'URL spécifiée. |
|
TableOfContents |
Indique que le sommaire du fichier d'aide HTML 1.0 est affiché. |
|
Topic |
Indique que la rubrique à laquelle l'URL spécifiée fait référence est affichée. |
Définissez la propriété HelpKeyword dans la fenêtre Propriétés. (la valeur de cette propriété sera passé au fichier d'aide afin de déterminer la rubrique d'aide à afficher).
Au moment de l'exécution, le fait d'appuyer sur F1 lorsque le contrôle (dont vous avez défini les propriétés HelpKeyword et HelpNavigator) a le focus ouvre le fichier d'aide associé à ce composant HelpProvider.
Remarque : Vous pouvez définir, pour la propriété HelpNamespace, une adresse http:// (telle qu'une page Web). Cela permet d'ouvrir le navigateur par défaut sur la page Web avec la chaîne indiquée dans la propriété HelpKeyword utilisée comme ancre (pour accéder à une section spécifique d'une page HTML).
Dans le code il faut utiliser la syntaxe HelpProvider.SetHelpKeyword=" "
Exemple :
Pour afficher la page d'aide sur les formes ovales, sélectionnez la valeur HelpNavigator.KeyWordIndex dans la liste déroulante Help Navigator, dans la zone de texte HelpKeyword, 'tapez « ovales » (sans chevrons).
Utilisation du bouton d’aide :
Vous pouvez afficher l'aide pour un contrôle via le bouton Aide (?) situé dans la partie droite de la barre de titre.
Il faut que l'utilisateur clique sur le bouton d'aide (?) puis sur le contrôle qui nécessite une aide, ce qui entraîne l'ouverture d'un carré blanc contenant un message d'aide.
L'affichage de l'aide de cette façon convient particulièrement aux boîtes de dialogue. En effet, avec un affichage modal des boîtes de dialogue, il n'est pas facile d'ouvrir des systèmes d'aide externes, dans la mesure où les boîtes de dialogue modales doivent être fermées avant que le focus puisse passer à une autre fenêtre. Le bouton Réduire ou Agrandir ne doit pas être affiché dans la barre de titre. Il s'agit d'une convention pour les boîtes de dialogue alors que les formulaires disposent généralement de boutons Réduire et Agrandir.
Pour afficher l'aide contextuelle :
Faites glisser un composant HelpProvider de la boîte à outils vers votre formulaire.
Le contrôle est placé dans la barre d'état des composants située au bas de la fenêtre. Attribuer aux propriétés Minimize et Maximize de la fenêtre la valeur false.
Puis,
Dans la fenêtre Propriétés de la fenêtre, donner à la propriété HelpButton la valeur true. Cette configuration permet d'afficher dans la partie droite de la barre de titre du formulaire un bouton contenant un point d'interrogation.
Sélectionnez le contrôle pour lequel vous souhaitez afficher l'aide dans votre formulaire et mettre dans la propriété HelpString la chaîne de texte qui sera affichée dans une fenêtre de type ToolTip.
Essayer le bouton (?):
Appuyez surF5.
Appuyez sur le bouton Aide (?) de la barre de titre et cliquez sur le contrôle dont vous avez défini la propriété HelpString. Le toolTip apparait.
Le composant ToolTip peut servir à afficher des messages d'aide courts et spécialisés relatifs à des contrôles individuels des Forms.
Cela ouvre une petite fenêtre indépendante rectangulaire dans laquelle s'affiche une brève description de la raison d'être d'un contrôle lorsque le curseur de la souris pointe sur celui-ci.
Il fournit une propriété qui précise le texte affiché pour chaque contrôle du formulaire.
En outre, il est possible de configurer, pour le composant ToolTip, le délai qui doit s'écouler avant qu'il ne s'affiche.
Comment faire : Ajoutez le contrôle ToolTip au formulaire.
Chaque contrôle à maintenant une propriété ToolTip ou on peut mettre le texte a afficher dans l'info bulle.
Utilisez la méthode SetToolTip du composant ToolTip. On peut aussi le faire par code :
ToolTip1.SetToolTip(Button1, "Save changes")
Par code créons de toute pièce un ToolTip.
Dim toolTip1 As New ToolTip()
' Modifions les délais du ToolTip. toolTip1.AutoPopDelay = 6000 toolTip1.InitialDelay = 2000 toolTip1.ReshowDelay = 500
' Force le ToolTip a être visible que la fenêtre soir active ou non.
toolTip1.ShowAlways = True
' donne le texte de l'info bulle à 2 contrôles. toolTip1.SetToolTip(Me.button1, "My button1") toolTip1.SetToolTip(Me.checkBox1, "My checkBox1")
