Apprenez à programmer en VB .NET
Last updated on Monday, June 24, 2013
  • 4 semaines
  • Facile

Ce cours est visible gratuitement en ligne.

Paperback available in this course

Ce cours existe en eBook.

Got it!

Fenêtres supplémentaires

Vous devez commencer à en avoir assez de travailler avec une seule et unique fenêtre. La plupart des programmes que vous utilisez en ont plusieurs. Ne serait-ce que pour afficher une fenêtre d'options, une fenêtre de visualisation et bien d'autres cas de figure.
Dans ce chapitre nous allons donc nous pencher sur l'ajout de fenêtres à notre projet, interagir avec elles, et leur faire échanger des données. Cela ouvrira la porte à des programmes plus complexes.
Plutôt que de regrouper des dizaines de fonctionnalités dans la même fenêtre, imaginez les répartir entre plusieurs : chaque feuille de code sera épurée et aura sa propre fonction. Voilà un des intérêts des fenêtres multiples.
Je ne vous en dit pas plus, à l'attaque !

Ajouter des fenêtres

Nous allons commencer par ajouter des fenêtres supplémentaires, puis nous apprendrons à les faire communiquer entre elles ! Créons tout de suite un nouveau projet de test Windows Forms avec le nom que vous souhaitez (pour moi ce sera FenetresSupplementaires).

On se retrouve comme à l'accoutumée avec notre fenêtre form1 gisant au beau milieu de notre feuille de design.

Vu que nous allons travailler avec plusieurs fenêtres, les noms de fenêtres vont être maintenant très importants.

Renommons donc cette fenêtre principale. Appelons-la Main (lorsque vous créerez un programme, je vous suggère de nommer cette première fenêtre avec le nom du programme).

Pour ce faire, cliquons une fois sur elle dans la fenêtre design pour avoir accès à ses propriétés. Dans la valeur Name, inscrivez donc Main, faites de même pour la valeur Text.

Puis renommons la feuille contenant cette fenêtre que nous voyons dans la fenêtre de solutions. Faites-un clic droit sur Form1.vb, puis renommez-la : inscrivez à la place Main.vb (voir figure suivante).

Renommez la feuille
Renommez la feuille

Voilà, vous venez de renommer entièrement votre fenêtre. Il faudra faire de même avec les supplémentaires.

Ajoutons une seconde fenêtre maintenant. Faites un clic droit sur le nom de votre projet (pour moi : FenetresSupplementaires), déplacez votre souris sur le menu Ajouter qui nous donnera accès à Nouvel élément et cliquez dessus. Une fenêtre proposant différents types d'éléments à ajouter à votre projet apparaît. Nous voulons une fenêtre, il va donc falloir sélectionner Windows Form (retenez bien cette manipulation, elle va nous permettre d'ajouter d'autres types d'éléments à notre projet). Pensez à renommer cette fenêtre, essayez de trouver un nom adapté à sa fonction. Vu que notre projet est là pour l'apprentissage et n'a aucune fonction particulière à remplir, je vais lui donner comme nom Secondaire.

Vous voici avec votre seconde fenêtre Secondaire qui s'est automatiquement ouverte. Comme vous avez pu le constater, les modifications de renommage que nous avons effectuées sur la fenêtre Main ont été automatiquement effectuées sur cette deuxième fenêtre (voir figure suivante).

Les modifications ont été effectuées
Les modifications ont été effectuées

Vous voilà avec votre première deuxième fenêtre (dur à suivre :) ). Allons nous amuser avec elle !

Ouverture et fermeture

Vous vous souvenez que je vous ai toujours appris à assigner des propriétés à vos contrôles en commençant la ligne par Me. : c'est dans ce chapitre que vous allez vous rendre compte de son utilité.

Créons tout de suite un contrôle sur notre seconde fenêtre, un bouton Fermer par exemple.

On vient à peine de la créer et tu veux déjà nous apprendre à la fermer ?

Oui, on va effectuer simplement un programme avec un bouton qui l'ouvre et un bouton permettant de la fermer. Donc, je crée mon bouton Fermer, identifié BT_FERMER. Me voilà donc avec seulement ce bouton dans ma fenêtre secondaire (voir figure suivante).

La fenêtre secondaire
La fenêtre secondaire

Créons donc un bouton Ouvrir identifié BT_OUVRIR sur la fenêtre principale (Main). Vous pouvez y accéder soit grâce au système d'onglets si vous ne l'avez pas fermée, soit grâce à la fenêtre de solutions en double-cliquant sur son nom.

Un bouton pour ouvrir une fenêtre
Un bouton pour ouvrir une fenêtre

Sur notre seconde fenêtre comme sur la première, si nous voulons accéder à des propriétés, il va falloir utiliser le Me. dans la page de code correspondante. En parlant d'elle, allons-y, créons l'événement BT_FERMER_Click en double-cliquant sur le bouton.

La fonction permettant de fermer une fenêtre individuelle est Close().

Tu nous avais parlé de End dans les autres chapitres.

Oui, End permet de fermer le programme, dans notre cas nous voulons fermer la fenêtre seule, il faut donc utiliser la fonction Close().

Maintenant l'objet sur lequel cette fonction va être exécutée est important. La feuille de code dans laquelle je me trouve actuellement correspond à la fenêtre secondaire. En utilisant le préfixe Me., l'objet de cette fenêtre sera automatiquement pris en compte. Si vous avez suivi, notre fonction va se retrouver sous cette forme :

Private Sub BT_FERMER_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_FERMER.Click
    Me.Close()
End Sub

Et donc avec cette méthode nous sommes certains que c'est cette fenêtre qui va être affectée par le Close() et donc fermée.

Retournons dans la fenêtre Main et double-cliquons sur le bouton Ouvrir pour créer son événement correspondant.

Et insérons dans cet événement le code nécessaire pour ouvrir une autre fenêtre qui est… la fonction Show().

Alors, si vous avez suivi mon monologue sur les objets, sur quel objet va-t-il falloir appliquer cette fonction ?

Eh bien, c'est sur l'objet de la fenêtre supplémentaire. Autrement dit l'objet Secondaire.

Ce qui nous donne :

Private Sub BT_OUVRIR_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_OUVRIR.Click
    Secondaire.Show()
End Sub

Pourquoi pas Me. ?

L'utilisation du préfixe Me. force l'utilisation de la fenêtre actuelle comme objet. Vous ne voulez pas afficher une fenêtre déjà ouverte ?

Si je teste, tout fonctionne : lors du clic sur Ouvrir, la seconde fenêtre s'ouvre, lors du clic sur Fermer, la seconde fenêtre se ferme.

Eh bien, vous avez déjà réussi à faire apparaître votre nouvelle fenêtre, puis à la fermer.

Notions de parent et d'enfant

Pourquoi veux-tu nous parler de famille ?

Non, non. Le concept de parent et d'enfant est aussi utilisé en informatique.

Je vais justement vous l'exposer sommairement ici.

Programmation orientée objet

La notion de parent/enfant est à l'origine utilisée en programmation orientée objet (abrégée en POO).

La POO est un style de programmation de plus en plus répandu. Certains langages ne sont pas orientés objet, d'autres le sont totalement. Notre langage, VB .NET utilise énormément la notion d'orienté objet.

Concrètement que nous apporte cette notion de POO ?

Eh bien, si vous voulez avoir plus de détails concernant la POO, je vous renvoie sur le tutoriel sur le C++ du Site Du Zero qui explique très bien le concept d'objet (réservé aux plus curieux d'entre vous).

Pour faire simple : on a introduit la notion d'objet pour pouvoir gérer plus facilement les gros programmes. Par exemple, dans nos programmes, les fenêtres sont toutes des objets bien distincts. Lorsque nous voudrons agir sur une fenêtre en particulier, il nous suffira de manipuler son objet.

Bon, j'essaie de suivre, mais pourquoi nous racontes-tu ça ?

Eh bien maintenant que je vous ai fait peur avec les objets :diable: , je vais vous parler des relations parent/enfant qui s'appliquent sur les objets.

L'héritage

Cette notion a été introduite avec la notion d'héritage.

L'héritage existait bien avant l'informatique…

Mais moi je vous parle de l'héritage en informatique. C'est un concept qui s'applique aux objets.

Imaginez que vous ayez un objet de type Instrument (eh oui, un objet peut être n'importe quoi du moment que vous le codez), cet objet va avoir des variables et des fonctions qui lui seront spécifiques (les notes qu'il est capable de jouer, la fonction Joue, etc.).

Si je crée un autre objet de type Guitare, vous voyez tout de suite qu'une guitare est un instrument, donc au lieu de recréer toutes les fonctions et variables qui existaient pour l'objet Instrument, je vais faire hériter ma Guitare de Instrument.

Regardez le schéma à la figure suivante.

Schéma de l'héritage
Schéma de l'héritage

Donc, chaque rectangle est un objet. Vous voyez l'objet Instrument, l'objet Guitare et l'objet Piano.
L'objet Guitare et l'objet Piano héritent tous les deux de l'objet Instrument.

Donc, la Guitare aura en plus de ses possibilités originelles (qui sont NbCordes et Vibrato()) celles de Instrument(qui sont Notes et Joue()). Pareil côté Piano.

Parent/enfant

Si je détruis l'objet Instrument, les objets qui en héritent (autrement dit Guitare et Piano) seront également détruits. Dans ce cas, Instrument est le parent, et Guitare et Piano sont les enfants.

J'en viens donc à notre problème actuel : les fenêtres.

Lorsque je lance mon programme, la première fenêtre, ici le Main, est considérée comme la fenêtre parent, et donc toutes les fenêtres supplémentaires créées seront ses enfants.
Si vous avez suivi ce que j'ai expliqué, si je ferme la fenêtre Main, les autres fenêtres se fermeront également.

Donc il va falloir faire bien attention à ça dans nos programmes. Ne pas fermer la fenêtre principale !

Et si je ne veux pas la voir ?

Eh bien il vous suffit d'effectuer un Visible = false sur cette dernière (j'ai dit que ce n'est pas bien, mais ici vous êtes obligés). Mais attention avec ça, ce n'est pas le tout de cacher la fenêtre et de ne jamais pouvoir la réafficher.

Bon, avec toutes ces nouvelles notions, nous allons pouvoir attaquer la communication entre fenêtres.

Communication entre fenêtres

Bon, après cette lourde partie théorique, attelons-nous à faire communiquer nos fenêtres entre elles.

Pourquoi diable aurais-je envie de faire ça ?

Eh bien, vous avez vu comment déclarer des variables. Vous ne voulez pas aller modifier les variables de la fenêtre d'à côté ? Écrire dans une textbox présente sur une autre fenêtre ?

Et puis même si vous n'avez pas envie, je vais quand même vous l'expliquer.

Manipulation de contrôles

Commençons par manipuler les contrôles, le plus facile.

Créons un label dans notre fenêtre principale nommée LBL_MAIN et un dans la fenêtre secondaire nommée LBL_SECOND. Enlevez-leur leurs textes pour ne laisser que du blanc.

Nous allons écrire un message dans le label de la fenêtre secondaire à son ouverture, mais à partir de la feuille de code de la fenêtre principale. Puis inversement lors de la fermeture de la fenêtre secondaire.

Si vous avez bien appréhendé toutes les notions d'objets, vous devriez être capables de le faire cela par vous-mêmes.

Pour manipuler un contrôle d'une autre fenêtre, il suffit d'inscrire le nom de la fenêtre souhaitée à la place du préfixe Me..

Soit, pour les deux événements présents sur les deux fenêtres :

Fenêtre Main :

Public Class Main

    Private Sub BT_OUVRIR_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_OUVRIR.Click
        Secondaire.Show()
        Secondaire.LBL_SECOND.Text = "J'ai réussi !"
    End Sub

End Class

Fenêtre Secondaire :

Public Class Secondaire

    Private Sub BT_FERMER_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_FERMER.Click
        Main.LBL_MAIN.Text = "De ce côté également"
        Me.Close()
    End Sub

End Class

Et le résultat à la figure suivante.

Le résultat
Le résultat

Nous avons réussi à manipuler des contrôles distants !

Manipulation des variables

Attaquons-nous donc tout de suite aux variables. Une petite précision supplémentaire va être requise pour cette partie.

Pour le moment nous déclarons nos variables avec un Dim à l'intérieur d'une fonction ou alors directement dans les arguments de la fonction. Nos variables avaient donc une « durée de vie » limitée. Une fois la fonction terminée, toutes les variables déclarées à l'intérieur cessaient d'exister.

Nous allons donc créer des variables globales de manière à ce qu'elles soient accessibles de partout.

Pour déclarer une variable globale, il faut placer son instruction de déclaration juste après l'ouverture du module.

Si elles sont créées comme je vous l'ai appris (Dim X as Integer), ces variables sont accessibles uniquement à partir de la fenêtre les ayant créées. Pour pouvoir y accéder depuis ailleurs, il va falloir les rendre publiques. Je vais donc vous apprendre un nouveau mot (programmatique) : Public.

Donc, si vous voulez des variables accessibles de « l'extérieur », il va falloir les déclarer ainsi.

On reprend donc le code de notre fenêtre secondaire en ajoutant cette variable globale et en assignant au label sa valeur lors du chargement de la fenêtre.

Public Class Secondaire

    Public MonString As String = ""

    Private Sub Secondaire_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Me.LBL_SECOND.Text = MonString
    End Sub

    Private Sub BT_FERMER_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_FERMER.Click
        Main.LBL_MAIN.Text = "De ce côté également"
        Me.Close()
    End Sub

End Class

Et voici le code de la fenêtre Main dans lequel j'accède à la variable MonString. J'ai volontairement retiré la ligne où je modifiais directement le label.

Public Class Main

    Private Sub BT_OUVRIR_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_OUVRIR.Click
        Secondaire.MonString = "Je crois que ça marche"
        Secondaire.Show()
    End Sub

End Class

Le résultat se trouve à la figure suivante.

Le résultat
Le résultat

Et voilà, votre première variable globale publique, et vous y avez déjà accédé à partir d'un autre objet !

  • On crée une nouvelle fenêtre au projet en effectuant un clic droit, puis Ajouter.

  • Une nouvelle fenêtre signifie un nouveau fichier.

  • On peut faire interagir les fenêtres entre elles pour leur envoyer ou recevoir des variables.

Example of certificate of achievement
Example of certificate of achievement