Appliquer Les Regles de Base de La Prog Even

ROYAUME DU MAROC
Office de la Formation Professionnelle et de la Promotion du Travail
Appliquer les concepts de base pour

développer une application
événementielle
DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

SECTEUR NTIC
ROYAUME DU MAROC
Office de la Formation Professionnelle et de la Promotion du Travail
DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

SECTEUR NTIC
Appliquer les concepts de base pour développer une application événementielle
VB.NET
Sommaire
1. L'interface utilisateur..............................................................................5
1.1. Comment créer une fenêtre?..............................................................5
1.2. Comment ajouter un bouton?.............................................................5
1.3. Comment ajouter un label?................................................................5
1.4. Modifier les propriétés de l'objet.........................................................6
1.5. Les propriétés communes des objets .................................................7
1.5.1. Name :......................................................................................7
1.5.2. Text : .......................................................................................7
1.5.3. Enabled : ..................................................................................8
1.5.4. Visible :.....................................................................................8
1.5.5. Font :........................................................................................8
1.5.6. BackColor ForeColor: ..................................................................8
1.5.7. Tag:
..........................................................................................................8
1.6. Evènements liés aux objets................................................................8
1.7. En résumé:....................................................................................10
2. Les Forms............................................................................................11
2.5. Propriétés......................................................................................11
2.5.1. Name :....................................................................................11
2.5.2. Text :......................................................................................11
2.5.3. Icon :......................................................................................11
2.5.4. WindowState :..........................................................................12
2.5.5. ControlBox...............................................................................12
2.5.6. MaximizeBox.............................................................................12
2.5.7. MinimizeBox.............................................................................12
2.5.8. FormBorderStyle.......................................................................12
2.5.9. StartPosition :...........................................................................12
2.5.10. MinSize et MaxSize..................................................................12
2.5.11. Opacity..................................................................................13
2.6. Evènements:..................................................................................14
2.7. Méthodes:......................................................................................14
2.8. System.Windows.Forms.Form...........................................................14
2.9. Formulaire d'avant plan:..................................................................15
Formateur :AZZI Hamid 3 2008/2009

VB.NET
3. Les Boutons.........................................................................................15
3.1. Créer un bouton :...........................................................................15
3.2. Modifier ses propriétés:....................................................................16
3.3. Utiliser les évènements:...................................................................16
3.4. Créer un bouton Ok ou Cancel:.........................................................17
3.5. Création d'un bouton par code:.........................................................17
3.6. Couleur transparente dans les images des boutons:.............................17
4. Les TextBox.........................................................................................18
4.1. Les contrôles TextBox......................................................................18
4.2. Le contrôle RichTextBox :.................................................................23
4.2.1. Qu'est ce que RTF?....................................................................23
4.2.2. Les bases du codage RTF............................................................24
5. Les Labels...........................................................................................24
5.1. Les labels.......................................................................................24
5.2. Les LinkLabel..................................................................................26
6. Les Cases à cocher...............................................................................27
7. Les Contrôles 'liste'...............................................................................28

7.1. Les 'ListBox'...................................................................................28
7.2. CheckedListBox...............................................................................32
7.3. Les ComboBox................................................................................33
7.4. Le Contrôle ListView :......................................................................34
8. Les fenêtres toutes faites.......................................................................36

8.1. MessageBox ..................................................................................36
8.2. InputBox........................................................................................38
9. Regroupement de contrôles...................................................................40
9.1. GroupBox et Panel...........................................................................40
9.2. PictureBox......................................................................................41
9.3. TabControl.....................................................................................41
10. Positionnons les contrôles....................................................................42
11. MainMenu contextMenu.......................................................................44
12. Avoir le Focus.....................................................................................46

VB.NET
1.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:
1.1. 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
WindowsForms.Form (En fait on a crée une Classe 'Form1')
1.2. 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.
1.3. 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:

VB.NET
1.4. 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 de propriétés de droite.
Dans le code des procédures les propriétés des objets sont aussi
accessibles.
Button1.Text="OK" permet par exemple de modifier la propriété Text
d'un bouton.

VB.NET
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.)
1.5. Les propriétés communes des objets

Celles héritées de la Classe ‘Control' qu’il faut connaître:
1.5.1. 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
1.5.2. 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’

VB.NET
ButtonOk.Text= "Ok"
1.5.3. 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
1.5.4. 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 utilise
la méthode .Show.
1.5.5. Font :
Permet le choix de la police de caractères affichée dans l’objet.
1.5.6. BackColor ForeColor:
Couleur du fond, Couleur de l’avant plan Pour un bouton Forecolor

correspond au cadre et aux caractères.
ButtonOk.ForeColor=System.Drawing.Color.Blue
1.5.7. 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 List1.Tag="CD"
cela permet ultérieurement de voir ce qu'il y a dans la liste.
Il y a bien d'autres propriétés.
1.6. Evènements liés aux objets

On a vu que les objets de l'interface utilisateur ont des
procédures déclenchées par les évènement de cet objet.
2 exemples:

VB.NET
1- Quand l'utilisateur clique sur un bouton Ok , la procédure

ButtonOk_Click s'effectue.
2- 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.
sender.Name 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 à déclenché la procédure. On peut même indiquer plusieurs
objets liés à cette procédure.
Certains évènement 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.

VB.NET
1.7. 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 lesprocédures.

VB.NET
2.Les Forms.
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 VB.net on parle de
formulaire.
2.5. Propriétés
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:
2.5.1. Name :
Nom du formulaire. Donner un nom explicite. 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.
2.5.2. Text :
C’est le texte qui apparaîtra dans la barre de titre en haut.

Text peut être modifié par le code : Form1.text= "Fenêtre"
2.5.3. 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.

VB.NET
Menu Fichier>Nouveau>Fichier cliquez sur Icon , Vb ouvre une fenêtre

Icon1 (dans l'éditeur d'images de Visual Studio.Net) 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.
2.5.4. 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)
2.5.5. 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.
2.5.6. 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.
2.5.7. 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.
2.5.8. 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
2.5.9. 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
2.5.10. MinSize et MaxSize

VB.NET
Donne les dimensions minimums et maximums que l'on peut utiliser pour
redimensionner une fenêtre.
2.5.11. Opacity
Allant de 0% (0) à 100% (1), permet de créer un formulaire plus ou

moins transparent.
Pour 0 il est transparent, pour 1 il est totalement opaque (normal)
Exemple:
Me.FormBorderStyle= Sizable
Me.ControlBox=False
Me.Size = New Size(100, 100)
Me.StartPosition = FormStartPosition.CenterScreen
Me.Opacity= 0.75
Donne au milieu de l'écran,la fenêtre:
Ouvrir une 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.

VB.NET
2.6. Evènements:
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..
2.7. Méthodes:
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 Me.Hide rend la fenêtre invisible.
Pour mettre la fenêtre au premier plan.
TopMost laisse toujours la fenêtre au premier plan alors que BringToFront
ramène la fenêtre au premier plan temporairement.
2.8. System.Windows.Forms.Form
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 System.Windows.Forms.Form: on voit bien dans le code:

VB.NET
Inherits Systeme.Windows.Forms.Form
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.
Quant on tape Dim f As New Form2() ,on crée une instance de la Class
Form2.
2.9. Formulaire d'avant plan:

Pour définir au moment de la conception un formulaire en tant que
formulaire d'avant-plan d'une application.
l 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
3.Les Boutons.
Ils sont omniprésent dans les 'formulaires'.
3.1. 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.

VB.NET
3.2. 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 a 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: button1.Text="Ok" affiche 'Ok' dans le bouton.
3.3. Utiliser les évènements:

L’évènement principalement utilisé est Click() : quand l’utilisateur clique
sur le bouton la procédure
Private Sub Button_Click(..)
End Sub est traitée.
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.

VB.NET
3.4. 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.
3.5. 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()
button1.Text="Ok"
' Ajouter le bouton à la Form
Controls.Add(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)
3.6. 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)

VB.NET
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.
4.Les TextBox
Les contrôles permettant de saisir du texte sont:
Les TextBox
Les RichTexteBox
4.1. Les contrôles TextBox.
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 hyper 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:
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':

VB.NET
Dim Nom As String
Nom= txtNom.Text
Dans btOk_Click il y a:
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… du moins pour être
exact,l'enrichissement affecte la totalité du texte et pas seulement une
partie) 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.
TextBox1.text= "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

textBox1.Undo()
' 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 à textBox2.Text=textBox2.Text+MonText
Evènements liés aux TextBox:

VB.NET
KeyDown survient quand on appuie sur le 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 (mais pas F1, F2..)
KeyDown et KeyUp permettent aussi de voir si MAJ ALT CTRL ont été
pressés.
On peut récupérer la touche pressée (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= textBox1.Text
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.

VB.NET

VB.NET
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?

Select Case e.KeyChar ' Compte les backspaces.
Case ControlChars.Back
Nombrebackspace = Nombrebackspace + 1
' Compte les 'ENTER' .
Case ControlChars.Lf
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 TextBox.text 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() 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.

VB.NET

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.
TextBox1.Text = TextBox1.Text.Insert(pos, ".")'on insère un '.'
TextBox1.SelectionStart = pos + 1 'on avance le curseur d'un
caractère
End If
End Sub
Autre solution?
4.2. Le contrôle RichTextBox :
Si vous êtes débutant passer à 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.
4.2.1. 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 enrichissement au format RTF , l’enrichissement est affiché :

VB.NET
4.2.2. 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.
RichTextBox1.Rtf = "{\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?
RichTextBox1.RTF= T 'T étant le texte enrichi
5.Les Labels
Il y a 2 sortes de Label:
Les Label et Les LinkLabel
5.1. Les labels.

On en a déjà utilisé pour afficher du texte non modifiable par l'utilisateur.

VB.NET
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ée attendu dans le
contrôle.
Exemple hyper simple: Comment indiquer à l'utilisateur qu'il faut saisir
son nom?
Donner votre
Nom:
La légende qui s'affiche dans l'étiquette est contenue dans la propriété

Text du label.
Pour modifier le texte du label1 par du code:
Label1.Text="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.
Label1.Text="Label avec une bordure et un fond jaune"

Label1.BorderStyle=BorderStyle.FixedSingle
Label1.ForeColor=Color.Red
Label2.BackColor=Color.Yellow
Donne:
Remarque: la plupart du temps les labels sont modifiés en mode design,

directement dans la fenêtre des propriétés.
Il est également possible d’y afficher une image avec la
propriété .Image
Remarque:
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
Label1.Text = 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

VB.NET
Refresh():
Dim i As Integer
For i = 0 To 100
Label1.Text = i.ToString: Label1.Refresh()
Next i
5.2. 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.
LinkLabel1.text= "Visitez le site LDF"

LinkLabel1.LinkArea = New System.Windows.Forms.LinkArea(11, 4)
Exemple :
‘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…

End Sub
Il est possible de modifier 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 envoyé 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(" http://plasserre.developpez.com/ ")
'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é.

VB.NET
6.Les Cases à cocher

Il y a 2 sortes de case à cocher: Les CheckBox et les RadioButton.
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.
RadioButton3.Text="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

VB.NET
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.)
Appearance peut 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é).
7.Les Contrôles 'liste'

Il y a 4 sortes de listes:
Les ListBox.
Les CheckedListBox
Les Combos
Les ListView.
7.1. Les 'ListBox'
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

VB.NET
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.Add, 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"
ListBox1.Items.Add("poisson")
Ajouter '4'
ListBox1.Items.Add(4.Tostring)
ou
ListBox1.Items.Add(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
ListBox1.Items.Add(i.ToString)
Next i

VB.NET

VB.NET
'Comment enlever des éléments?

' Enlever l'élément d'index 5:
ListBox1.Items.RemoveAt(5)
' Enlever l'élément sélectionné:
ListBox1.Items.Remove(ListBox1.SelectedItem)
' Enlever l'élément "Tokyo":
ListBox1.Items.Remove("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, quelles é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ées.
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:

VB.NET
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 = List1.Items.Add("Hello")
List1.SelectedIndex = x
On utilise la valeur retournée (x dans notre exemple) par la méthode

Add. (NewIndex n'existe plus en VB.NET)
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 VB.Net!!
Il faut utiliser les fonctions de compatibilité:
VB6.SetItemData(ListBox1, 0, 123) 'pour lier à l'élément 0 la valeur
123. C'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.
7.2. CheckedListBox
C’est une Listbox mais avec une case à cocher sur chaque ligne.

VB.NET
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 &
ControlChars.CrLf
Next x
MessageBox.Show(s)
End If
On rappelle comme toujours que quand on parle du 3eme élément cela

correspond à l’index 2.
7.3. Les ComboBox
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.

VB.NET
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.
Items.Add (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
Label1.Text = ComboBox1.Text
End Sub
7.4. Le Contrôle ListView :
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 et SmallIcone
Par programmation cela donne : ListView1.View= View.Details
Utilisons le mode détails (Appelé mode Rapport)

VB.NET
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 :
ListView1.Colonns.Add (« Nombre », 60, HorizontalAlignment.Left)
..
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
LVI.Text = i.ToString
LVI.SubItems.Add((i * i).ToString)
LVI.SubItems.Add((i * i * i).ToString)
ListBox1.Items.Add(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
Label1.Text =ListBox1.SelectedIndices(0).ToString
End Sub

VB.NET
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, ruser sur la largeur des colonnes (c’est le
2eme paramètre de la méthode .Columns.Add)
8.Les fenêtres toutes faites.

Il existe :
Les MessageBox.
Les InputBox
Ces fenêtres toutes faites pour faciliter le travail :
8.1. 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= MessageBox.show(TexteAAfficher,Titre, TypeBouton

etIcone, BoutonParDéfaut)
Exemple:
Paramètres

VB.NET
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.Yes
DialogResult.No
DialogResult.Cancel
DialogResult.Retry
DialogResult.Ok
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 MessageBox.Show ( qui est VB.NET) plutôt que
MsgBox qui est de la compatibilité avec VB
Exemple :
Reponse=MessageBox.Show(«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’

VB.NET
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.
response = MsgBox(msg, style, title)
If response = MsgBoxResult.Yes 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.
8.2. InputBox
C'est 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 :

VB.NET
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.
OpenFileDialog
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= DialogResult.Ok 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.
SaveFileDialog
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

VB.NET
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é DialogResult.Ok.
Il existe aussi:
LoadDialog
PrintDialog
9.Regroupement de contrôles
On peut regrouper des contrôles dans :
Les GroupBox.
Les Panels.
Les PictureBox.
Les TabControl.
9.1. GroupBox et Panel

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

VB.NET
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 Pressepapiers,
sélectionnez le contrôle Panel et collez-les.
9.2. PictureBox
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.
9.3. TabControl
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.
Evènement commun.
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.

VB.NET
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)
Handles CouleurVert.CheckedChanged,
CouleurRouge.CheckedChanged, CouleurBleu.CheckedChanged
End Sub
Cette procédure est activée quand les case à 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 sender.Name

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...
10. Positionnons les contrôles

On peut Dimensionner les contrôles : Les positionner.
Tous les contrôles héritent donc tous de la classe Windows Forms.
Les contrôles ont tous des propriétés communes.
Unité de mesure :
L'unité de mesure est le 'Pixel' (Picture Elément).(plus de twips)
Les coordonnées d'un contrôle se définissent à partir du coin supérieur
gauche du conteneur.

VB.NET
Pour la taille :
On peut utiliser: Left, Top coordonnées du coin supérieur gauche et
Bottom, Right inférieur droit.
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 peuvent aussi être utilisées.
Exemple : Button.left=188 Button.Top =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 que l’utilisateur puisse redimensionner la fenêtre(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 VB.net, 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’ils
s’adaptent à la nouvelle fenêtre) En VB.Net 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 bords 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 a 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.

VB.NET
Dock
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.
Spliter
Le contrôle Splitter sert à redimensionner des contrôles au Moment de
l'exécution par l'utilisateur.
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, ancrer le contrôle à Redimensionner au bord d'un
conteneur, puis ancrez un contrôle Splitter sur le même côté de ce
conteneur.
11. MainMenu contextMenu.

Main Menu
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

VB.NET
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’ : 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é.
Menu Contextuel
C'est un menu qui s'ouvre quand, le curseur de l'utilisateur est sur un
objet, et qu'il 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.

VB.NET
12. Avoir le Focus.

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é 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 a 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
Cascade d'évènement quand on prend ou on perd le focus:
Il se déclenche dans l'ordre:

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.

VB.NET
On va quitter le contrôle, il fau vérifier la validité avant. 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 certaine donnée 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: le focus reste sur
Button1
End If
End Sub
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 formulaire
(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.
Usage du clavier pour passer d'un contrôle à l'autre.
Dans une application où un utilisateur tape 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 en cours de
conception 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.
Raccourcis clavier.
Dans beaucoup d'applications certains contrôles ont un raccourci clavier:
Exemple: Nouveau est une ligne de menu. Etant 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 affichera bien Nouveau et ALT N
fonctionnera.

VB.NET
Pour une TextBox, la propriété text ne peut pas être tilisée, aussi il faut
mettre devant la textBox un contrôle label (qui lui ne peut pas avoir le
focus), si les TabIndex du label et du TextBox se suivent, le fait de
faire le raccourci clavier du label donne le focus au TextBox.
Exemple quand l'utilisateur tape Alt-N, le focus va dans le TextBox

dessous.


Appliquer Les Regles de Base de La Prog Even

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Appliquer Les Regles de Base de La Prog Even

Uploaded by

Copyright:

Available Formats

ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

Appliquer les concepts de base pour

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

Office de la Formation Professionnelle et de la Promotion du Travail

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

Formateur :AZZI Hamid 3 2008/2009

6. Les Cases à cocher...............................................................................27

7. Les Contrôles 'liste'...............................................................................28

8. Les fenêtres toutes faites.......................................................................36

10. Positionnons les contrôles....................................................................42

11. MainMenu contextMenu.......................................................................44

12. Avoir le Focus.....................................................................................46

Formateur :AZZI Hamid 4 2008/2009

1.1. Comment créer une fenêtre?

Menu Projet, Ajouter un formulaire Windows, cliquer sur WindowsForm,

1.2. Comment ajouter un bouton?

1.3. Comment ajouter un label?

Formateur :AZZI Hamid 5 2008/2009

1.4. Modifier les propriétés de l'objet.

Formateur :AZZI Hamid 6 2008/2009

1.5. Les propriétés communes des objets

Il s’agit du nom de l’objet tel qu’il est géré par l’application.

Il est vivement conseillé, avant toute autre chose, de rebaptiser les

Btn pour les Boutons

il s’agit du texte qui est associé à l’objet.

Formateur :AZZI Hamid 7 2008/2009

Accessible, Indique si un contrôle peut répondre à une interaction

Indique si un contrôle est visible ou non. ButtonOk.Visible=False fait

Permet le choix de la police de caractères affichée dans l’objet.

1.5.6. BackColor ForeColor:

Couleur du fond, Couleur de l’avant plan Pour un bouton Forecolor

Permet de stocker une valeur ou un texte lié à l'objet. Chaque objet a un

1.6. Evènements liés aux objets

Formateur :AZZI Hamid 8 2008/2009

1- Quand l'utilisateur clique sur un bouton Ok , la procédure

La syntaxe complète de la procédure est:

Private Sub CouleurRougeCheckedChanges (ByVal sender As

La procédure évènement est privée (Private). Après le nom Sub il y a un

On voit que quand on crée un objet, ses procédures évènements sont

On se rend compte que dans une procédure évènement on peut modifier

Certains évènement sont communs à tous les contrôles:

Il y a toujours des méthodes Changed déclenchées par un changement

Formateur :AZZI Hamid 9 2008/2009

Formateur :AZZI Hamid 10 2008/2009

Menu Projet, Ajouter un formulaire Windows, cliquer sur WindowsForm,

Nom du formulaire. Donner un nom explicite. FrmDemarrage Dès qu’une

C’est le texte qui apparaîtra dans la barre de titre en haut.

Propriété qui permet d’associer à la Form un fichier icône. Cette icône

Comment créer une icône?

Formateur :AZZI Hamid 11 2008/2009

Menu Fichier>Nouveau>Fichier cliquez sur Icon , Vb ouvre une fenêtre

Donne l’état de la fenêtre : Plein écran

Si cette propriété à comme valeur False, les boutons de contrôle situés à

Si cette propriété à comme valeur False, le boutons de contrôle ‘Plein

Si cette propriété à comme valeur False, le boutons de contrôle ‘Minimize’

Permet de choisir le type des bords de la fenêtre : sans bord (None),

Permet de choisir la position de la fenêtre lors de son ouverture.

2.5.10. MinSize et MaxSize

Formateur :AZZI Hamid 12 2008/2009

Allant de 0% (0) à 100% (1), permet de créer un formulaire plus ou

Donne au milieu de l'écran,la fenêtre:

Ouvrir une fenêtre