vendredi 9 octobre 2009

Atelier 02 - Définir l'interface utilisateur de l'application

Définir l'interface utilisateur de l'application

Nous allons apprendre à :
  • Créer un projet de développement type formulaire Windows
  • Positionner les différents contrôles graphiques de l'interface utilisateur
  • Localiser l'application dans différentes langues
Contexte fonctionnel
Nous sommes développeurs, et nous avons à implémenter des écrans qui ont été décrits dans l’analyse fonctionnelle, ou mieux qui ont été conçus par un designer d’application à base de formulaire (on peut rêver un peu, non ?). Plus probablement, on nous a donné un bout de feuille issu d’une réunion et qui décrit ce qu’il faudrait faire :



Créer le projet et la fenêtre principale


Après avoir ouvert Visual Studio, nous choisissons de créer un nouveau projet de type Windows Forms Application, que l'on va appeler Coach.Editeur
Un nouveau projet avec une forme vide s'est ouvert...

Nous allons commencer par renommer Form1.cs en cliquant droite sur l'explorateur de document et rename pour l'appeler Main.cs

Visual Studio nous propose ici de chercher automatiquement dans le projet en cours tous les endroits où il y a une référence au nom de la fenêtre Form1 et de les remplacer par le nouveau nom donné Main. Il va s’occuper pour nous de renommer les variables et autres éléments, ce qui est très utile donc.

En fait, un formulaire Windows est avant tout une classe d’objet (d’ailleurs tout est classe d’objet dans .Net ?). En double cliquant sur le nom de la fenêtre Main.cs dans l’Explorateur de solutions, nous verrons le designer de formulaire qui affiche l’interprétation du code de définition de la classe.

Un formulaire Windows est composé d’au moins deux fichiers dans Visual Studio. Le fichier Main.cs contient tous les codes que nous allons programmer, et le fichier Main.Designer.cs contient tous les codes qui sont générés par Visual Studio. Le code généré est exactement celui que nous devrions développer à la main si nous voulions faire l’équivalent de ce que fera le générateur. Il n’y a ainsi aucun code caché et la totalité du code est accessible ! Il ne faut pas hésiter à aller y jeter un coup d’œil, mais ne nous lançons pas à le modifier si nous ne savons pas ce que nous faisons, sauf pour corriger des éventuelles erreurs de compilation liées à des destructions intempestives de contrôles par exemple.

Comment fait Visual C# Express pour s’y retrouver dans ces fichiers ? En fait, la définition d’une classe peut être découpée en plusieurs fichiers. Pour indiquer à Visual C# Express qu’il va devoir recoller les morceaux, on ajoute à la directive de classe le mot partial :
public partial class Main : Form
C’est quoi une classe partielle ? On parle de classe partielle quand la définition de la classe est découpée en plusieurs fichiers. C’est très utile si nous avons plusieurs développeurs qui travaillent sur des parties différentes d’une même classe.

Sur notre formulaire, nous allons faire un clique-droit pour afficher les propriétés (qui vont apparaîtres normalement en bas à droite, en dessous de l'explorateur de solution). On vérifie que nous sommes sur le bon projet (Main System.Windows.Forms.Form mais vu qu'on en a qu'une... Sinon dans la liste déroulante, il faudrait sélectionner la bonne)

Dans la fenêtre de Propriétés, les propriétés affichées en gras sont celles que nous avons modifiées. Les autres indiquent les valeurs par défaut. Pour chacune des propriétés dont la valeur indiquée est différente de la valeur par défaut, Visual Studio va générer une (ou plusieurs) ligne(s) dans le fichier Main.Designer.cs ;

Dans la fenêtre Propriétés, nous allons changer la propriété Text et écrire Editeur du Coach C#, ce qui va avoir pour effet de changer le titre de la fenêtre.
Dans Microsoft .net, la propriété Text référence toujours ce qui est affiché par le contrôle à l’écran, même pour les labels ou les boutons.

Dans la propriété size, nous allons mettre 727 pour width et 427 pour height.



Définition d'un menu


On va à présent ajouter une barre de menu sous le titre de la fenêtre (comme il en existe dans la plupart des programmes) ainsi qu'un menu contextuel quand on clique-droite sur l'icône qui se trouvera dans la zone de notifications.

Nous allons ajouter le menu avec la toolbox (boîte à outils) qui se trouve à gauche de l'écran. Pour afficher la toolbox, nous devons être en mode [design]

Nous pouvons ajouter et supprimer des éléments dans la toolbox en faisant un clique-droit et en sélectionnant "Choose Items..."

Dans l'onglet "menus and toolbars", on glisse l'élément MenuStrip sur notre formulaire. Deux choses apparaissent sur notre formulaire, une barre de menu vide en dessous du titre et un contrôle de menu (MenuStrip1) dans une nouvelle zone de dépôt de contrôle en bas de la zone de travail. On va aller dans les propriétés du contrôle de menu (clique-droit) et on change le nom en mainMenuStrip de la propriété Name.

Le langage C# est sensible à la casse des mots. Autrement dit MainMenuStrip ne représente pas la même chose que mainMenuStrip. Il nous faut donc penser à systématiquement faire attention à la façon dont nous nommons nos variables et composants afin d’éviter les erreurs de compilation. Le meilleur moyen est de suivre un plan de nommage et de notation précis.

Avec un clique-droit sur le menu que nous venons d'ajouter, nous allons sélectionner Insert Standards Items... La magie opère, et nous trouvons les principaux menus. Ils ne sont par contre pas fonctionnels pour le moment.

On va faire un double-clique dans File - Exit et une méthode exitToolStripMenuItem_Click apparaît dans Main.cs. Dans cette méthode, nous allons ajouter le code
this.Close();
Après avoir sauvé notre projet, nous pouvons l'exécuter, et tester la fonction du menu Exit... Le programme se ferme :)

C’est quoi this ? Le mot clé this référence l’instance courante d’un objet. Dans notre cas il s’agit donc de l’instance de la fenêtre Main qui sera créée lors de l’exécution du programme

Mais comment fait le système pour retrouver la bonne méthode à exécuter quand on clique sur Quitter ?
Ce n’est pas le nom de la méthode qui fait foi. En fait, la fonction de prise en charge de l’événement (ou la méthode de réponse à l’événement, qui se dit « Event Handler » en anglais) a été dans notre cas automatiquement paramétrée par Visual Studio dans le fichier Main.Designer.cs lorsque nous avons fait un double clic sur le menu Quitter. Nous allons aller voir la définition (faites attention de ne rien modifier ?) :
  • Ouvrons le fichier Main.Designer.cs en double cliquant dessus dans l’Explorateur de solutions
  • Dans ce fichier, cherchez la partie qui est automatiquement générée par Visual Studio
  • On clique sur le petit + pour faire voir le code
  • On cherche exitToolStripMenuItem
  • L'action du click est ici :
this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click);
Aucun code n'est caché... On peut également voir l'ensemble des événements disponibles pour le menu quitter, en faisant un clique-droit sur Exit et ensuite Properties. En cliquant sur le petit éclair (Events), nous remarquons que seul l'événement Click possède une méthode de réponse.

Pour ajouter une fonction de réponse à un événement, il suffit d’aller visualiser la liste des événements disponibles sur le contrôle sélectionné et de double-cliquer sur le nom de l’événement. Cela va ajouter automatiquement la fonction dans notre fichier de code (par exemple Main.cs), et le paramétrage de l’événement dans le fichier utilisé par le designer de Visual Studio (par exemple Main.Designer.cs). Au lieu de double-cliquer, nous pourrions aussi indiquer un nom quelconque pour la fonction de prise en charge (« toto » par exemple), et au moment ou nous allons taper Entrée, Visual Studio va tout créer pour nous. Si nous détruisons la fonction de réponse de notre fichier de code, il faudra aussi penser à retirer le paramétrage de l’événement dans le fichier utilisé par le designer, Visual Studio ne pouvant le faire pour nous car il ne sait pas si la destruction (ou le changement de nom) est consécutif à une erreur ou à un choix décidé du programmeur. De toute manière, si nous ne le faisons pas, nous obtiendrons une erreur de compilation (et oui, le compilateur C# vérifie un maximum de chose).



Nous allons à présent ajouter un menu contextuel qui apparaîtra dans la barre de notifications quand nous ferons un clique-droit.
Pour ce faire, nous devons suivre quatre étapes :
  • Ajouter une icône s'affichant dans la barre de notification et la paramétrer
  • Ajouter un menu contextuel et le paramétrer
  • Lier l'icône de notification et le menu contextuel
  • Ajouter le code correspondant aux options du menu contextuel
On reprend notre formulaire en mode [design] et dans les outils, nous cherchons les common objects. On glisse et déplace le contrôle NotifyIcon sur le formulaire, et nousle voyons apparaître dans la zone de dépôt de contrôles.
Nous allons modifier le name de ce contrôle en mainNotifyIcon en allant dans les propriétés.
Nous allons également modifier la propriété Text et lui attribuer la valeur "Editeur du Coach C#". Ce texte apparaîtra lorsque nous laisserons la souris sur l'icône lorsque le programme sera exécuté.

Nous allons à présent faire un tour dans les propriétés de Coach.Editeur et ajouter un fichier existant dans les ressources. Nous sélectionnons l'icône (fournie avec le projet de test chez Microsoft)

Nous affichons à présent le code de Main.cs (notre formulaire) et nous cherchons la méthode Main(). Il s'agit du constructeur de classe.

C’est quoi un constructeur ?
Le constructeur est la méthode membre d’une classe que vous allez appeler à chaque fois que vous instanciez un nouvel objet :
Main main = new Main();
Main (type de la variable) main (nom de la variable) = new Main() (méthode membre pour l'instanciation)
L’objectif du constructeur est de créer convenablement une instance d’objet, en le configurant dans un état valide. En C#, le constructeur répond aux caractéristiques suivantes :
  • Le nom du constructeur est rigoureusement le même que le nom de la classe
  • Le constructeur n'a aucun type de retour spécifique (pas même void)
Comme toute méthode membre, il est possible de passer des paramètres au(x) constructeur(s) d’une classe. Il est ainsi possible de définir plusieurs façons convenables de créer une instance d’objet. C’est notamment visible dans l’IntelliSense qui nous propose de sélectionner un des différents constructeurs disponible.

Le constructeur qui ne possède aucun paramètre passé est appelé le constructeur par défaut.

Dans le constructeur Main, nous allons ajouter le ode pour initialiser l'icône du contrôle mainNotifyIcon avec celui chargé en ressource :
mainNotifyIcon.Icon = Properties.Resources.lan_connected;
(lan_connected étant l'icône que nous avons ajoutée)

Nous sauvons et revons dans le mode [design]. Dans la toolbox, nous retournons dans Menus & Toolbars et nous glissons ContextMenuStrip dans notre formulaire. Il va se retrouver dans le zone de dépôts de contrôles.

Un menu contextuel ne s’affichant pas hors de son contexte (c’est une Lapalissade), dès que le contrôle du menu contextuel n’est plus sélectionné dans la zone de dépôt de contrôles, il disparaît de l’écran. Pour l’afficher de nouveau, il nous suffit de sélectionner le contrôle dans la zone de dépôt de contrôles.

On va renommer notre contrôle ContextMenuStrip1 en mainNotificationIconContextMenuStrip (Properties -> Name)

Juste en dessous du menu standard, on va cliquer sur la boîte de texte ContextMenuStrip (Type here) et saisir "Maximiser la fenêtre". Nous allons également ajouter "Restaurer la fenêtre", "Minimiser la fenêtre" et "Quitter l'application". On clique à présent sur le "Type here" qui nous laisse apparaître une petite flèche d'une liste déroulante et on ajoute un Separator.

La liste déroulante nous aide à insérer un autre type de ligne de menu : le MenuItem correspond à une ligne de menu similaire à celles que nous venons de saisir, une ComboBox ajoute une liste déroulante, et le TextBox nous permet de saisir directement une valeur de menu lors de l’exécution de l’application. Il reste le Separator, que nous allons utiliser, et qui ajoute simplement une ligne grise horizontale dans la liste des menus.

Nous faisons glisser la ligne de séparation juste en dessus de "Quitter l'application". Nous allons à présent dans les propriétés de mainNotifyIcon. Nous allons changer la valeur de ContextMenuStrip en utilisant la liste déroulante proposée et nous allons sélectionner mainNotificationIconContextMenuStrip. Nous allons pouvoir à présent tester notre programme en le lançant en mode debug et ainsi voir apparaître l'icône dans la barre de notification, ainsi que son menu contextuel (qui ne fonctionne pas, car nous ne l'avons pas encore encodé)

Nous allons maintenant développer les méthodes de réponse aux événements Click de chacun des menus.

Nous cliquons dans la zone de dépôt de contrôles sur mainNotificationIconContextMenuStrip afin de le faire apparaître en dessous du menu standard et faire un double-clique sur "Quitter l'application" du menu contextuel.

Une méthode quitterLapplicationToolStripMenuItem_Click apparaît dans notre code de Main.cs. Nous allons y ajouter la ligne de code qui nous permet de ferme l'application :
this.Close();
Nous allons faire plus ou moins pareil avec l'option "Maximiser la fenêtre".

La propriété que nous allons utiliser est WindowsState de l’instance de la fenêtre Main en cours (renvoyée par this). Cette propriété, accessible en lecture et en écriture obtient ou définit l’état de la fenêtre du formulaire.

Le type de cette propriété est FormWindowsState, qui est en réalité une énumération de variables à valeurs constantes (enum en C#)

Les trois valeurs possibles proposées par cette énumération de valeurs sont : Maximized, Minimized et Normal (en fait, chacune de ces valeurs correspond à un entier unique dans la liste des valeurs, mais c’est bien plus lisible avec une énumération ;))

C’est quoi un Type?
Le Type indique globalement la taille qu’un objet va utiliser en mémoire, la façon dont on va accéder à cette mémoire, et tout ce que cet objet peut faire. C# est un langage fortement typé. Autrement dit, tous les objets que nous allons utiliser ou que nous allons créer en C# doivent avoir un type. Le système de types C# comporte principalement des types valeurs (ou types intrinsèques) et des types références. Les variables de type valeur stockent directement des données (comme un entier ou une date) car le système sait exactement la taille à allouer pour ces données (un int32 fait toujours 32 octets !), alors que les variables de type référence stockent les références aux données (en gros, l’adresse des données en mémoire), car le système ne sait pas nécessairement la taille à allouer (quelle est la taille d’une liste de clients ?). Les types références sont également considérés comme des objets.

C’est quoi une variable ?
Pour les puristes, une variable est une instance d’un type par valeur (type intrinsèque). Bon, de mon coté, je désigne (comme la plupart des développeurs) une variable comme une instance d’un type quelconque, par valeur ou par référence (voire par pointeur si vous devez intégrer des librairie existante en C++ ?). Une variable est composée d’un type et d’un identificateur (aussi dit nom de la variable) :
int counter;
Assigner une variable, c’est lui donner une valeur en mémoire, soit à sa création, soit ultérieurement lors de l’exécution du programme. Une variable est donc fondamentalement en lecture/écriture (d’où son caractère variable [cqfd]).

A la différence d’autres langages du marché, l’assignation des variables est obligatoire en C#. Autrement dit, nous devons nécessairement définir la valeur par défaut que va avoir votre variable, le compilateur ne pouvant le décider pour nous – cela évite bien des bugs difficiles à détecter lors de l’exécution.

C’est quoi une constante ?
Une constante est une variable dont la valeur ne peut pas être changée lors de l’exécution du programme (elle est en lecture uniquement).
Une constante littérale est juste une valeur, comme 6, 12 ou "Coucou" ; D’ailleurs, tapons un point juste après la constante littérale "Coucou" , et nous obtenons par l’IntelliSense tout ce qu’il est possible de faire sur une chaîne de caractères (magique, non ?).

Une constante symbolique est l’assignation d’un nom à une valeur. La déclaration d’une constante symbolique est réalisée par la ligne suivante :
const int valeurMaximumDuCompteur = 42;
C’est quoi une énumération ?
Une énumération est un ensemble de constantes symboliques nommées. Par exemple, en utilisant Reflector pour décompiler le code de l’énumération System.Windows.Forms.FormWindowState (c’est l’énumération que l’on va utiliser – il ne faut pas oublier que l’objectif est de mettre en place le code pour maximiser la fenêtre [c’est fou ce que l’on peut dire à propos d’une seule ligne ?]), on obtient le code suivant :
public enum FormWindowState
{
Normal,
Minimized,
Maximized
}
La valeur des constantes de la liste n’étant pas précisée, le compilateur affecte des valeurs entières en commençant à 0 ; le code ci-dessus est donc similaire à :
public enum FormWindowState
{
Normal = 0,
Minimized = 1,
Maximized = 2
}
Pour revenir à notre code, après avoir double-cliqué sur "Maximiser la fenêtre" nous allons ajouter le code suivant :
private void maximiserLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
// Maximise la fenêtre en cours
this.WindowState = FormWindowState.Maximized;
}
Nous allons faire pareil avec Minimiser et Restaurer :
private void restaurerLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Normal;
}

private void minimiserLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Minimized;
}
Un truc sympathique à faire serait de griser les menus contextuels qui sont inutiles en fonction du contexte de la fenêtre. Par exemple, le menu Maximiser la fenêtre pourrait être grisé quand la fenêtre est en état maximisé.

La propriété que nous allons utiliser est Enabled sur chacun des menus contextuel, en indiquant une valeur booléenne true ou false, pour respectivement le rendre actif ou le griser ;

Où faut-il connecter le code ? Si on regarde le besoin fonctionnel, on a :
le menu Maximiser la fenêtre doit être grisé quand la fenêtre est en état maximisé ; Bon, on va faire un peu d’analyse …

L’utilisation de la conjonction quand dans l’expression fonctionnelle indique l’utilisation d’un événement déclencheur : quand la fenêtre est en état maximisé . Nous allons donc utiliser une fonction de réponse à un événement (« event handler ») ;

La conjonction quand dans l’expression fonctionnelle est généralement suivie de l’objet sur lequel l’événement va porter : quand la fenêtre est en état maximisé. La fonction de réponse à l’événement va donc porter sur la fenêtre en cours (i.e. sur l’objet Main) ;

L’auxiliaire de l’expression fonctionnelle est généralement (dans le cas des événements) suivi du nom francisé (au sens large) de l’événement : quand la fenêtre est en état maximisé. C’est utile lorsqu’on ne connaît pas, à priori, le nom de l’événement à utiliser.

Où faut-il connecter le code, donc ? Dans notre cas, nous allons donc chercher s’il existe, sur l’objet fenêtre (« Form ») un événement comme « StateMaximized », ou « Maximized », ou encore un autre en relation avec la dimension de la fenêtre (« Size » en anglais), car maximiser une fenêtre revient à en changer la taille ; Et c’est là que nous allons connecter le code !

Nous allons faire un clique-droite sur le formulaire (en mode [design]) et ouvrir les propriétés. On clique sur le petit éclair (les events). On s'assure que nous sommes bien sur l'objet Main dont le nom s'affiche en haut dans la liste déroulante.
Dans la liste des événements disponibles, nous allons chercher quelque chose qui se rapproche de State mais comme il n'y en a pas, nous allons nous rabattre sur SizeChanged.

Lorsqu’un événement est au prétérit (c'est-à-dire avec ed à la fin), alors il est déclenché après que l’action ait eu lieu. Par exemple, SizeChanged est déclenché après le changement de taille de la fenêtre, ou encore FormClosed est déclenché après la fermeture de la fenêtre. Si l’événement est au présent progressif (c'est-à-dire avec ing à la fin), l’événement est déclenché en tout début d’action, et il est généralement possible d’interagir avec cette action. Par exemple, FormClosing est déclenché en début de processus de fermeture de la fenêtre et il est possible d’annuler ce processus en laissant la fenêtre ouverte (ce qui est pratique si vous avez des données non sauvegardées …) ;

On fait un double-clique sur l'événement SizeChanged et une méthode est créée dans le code.

L’idée de cette méthode est de configurer la propriété Enabled de chacun des menus contextuels à vrai (true) ou faux (false), en fonction de l’état de la fenêtre.

La méthode va avoir la forme suivante :
private void Main_SizeChanged(object sender, EventArgs e)
{
// Grise les menus en fonction de l'état de la fenêtre
this.maximiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Maximized);
this.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Minimized);
this.restaurerLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Normal);
}
Le code this.WindowState == FormWindowState.Minimized utilise l’opérateur d’égalité == . Pour les types valeurs, l'opérateur d'égalité == retourne true si les valeurs des opérandes sont égales et false dans le cas contraire. Pour les types références autres que string, == retourne true si ses deux opérandes font référence au même objet. Pour le type string, == compare les valeurs des chaînes.

Le code this.WindowState == FormWindowState.Minimized retourne donc true dans le cas où l’état de la fenêtre est minimisé. Mais nous aimerions que le menu contextuel Minimiser la fenêtre soit grisé quand l’état de la fenêtre est minimisé. Nous allons donc utiliser un autre opérateur, celui de négation logique.

L'opérateur de négation logique ! est un opérateur qui applique une négation sur l’opérande. Il est défini pour un opérande de type booléen et retourne true si, et seulement si, l'opérande est false, et inversement.

Le code !(this.WindowState == FormWindowState.Minimized) retourne donc false dans le cas où l’état de la fenêtre est minimisé, et c’est justement ce que nous aimerions afin que le menu contextuel Minimiser la fenêtre soit grisé quand l’état de la fenêtre est minimisé. Il nous reste donc à assigner la propriété Enabled du contrôle correspondant avec cette valeur, en utilisant l’opérateur d’assignation = ;

L'opérateur d'assignation = stocke la valeur de l'opérande de droite dans l'emplacement de stockage, la propriété (ou l'indexeur, mais cette notion est pour plus tard dans le coach) stipulé par l'opérande de gauche, et retourne la valeur comme résultat.
Les opérandes doivent être de même type (ou l'opérande de droite doit être implicitement convertible au type de l'opérande de gauche).

Et voilà, la ligne de code :
this.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Minimized);
grise donc le menu contextuel Minimiser la fenêtre quand la fenêtre est en état minimisé !

A la différence d’autres langages du marché, en C# l’opérateur d’assignation = est différencié de l’opérateur d’égalité ==, ce qui réduit fortement les risques de mauvaise interprétation des expressions.

Il nous reste à présent à griser le "Restaurer la fenêtre" au démarrage de l'application. En ligne de code, nous allons donc ajouter dans la méthode Main :
// Griser le menu Restaurer la fenêtre
this.restaurerLaFenêtreToolStripMenuItem.Enabled = false;
On peut sauver, et tester. Normalement, tout fonctionne comme nous l'avons souhaité, et nous savons à présent jouer avec les fenêtres et le menus.

Aucun commentaire:

Enregistrer un commentaire