La construction d'interfaces graphiques en Java.

Généralités

La construction d'interfaces graphiques en Java repose sur un système à base de fenêtres. Deux bibliothèques de composants d'interfaces (boutons, fenêtre de listes, boîtes combo, cases à cocher etc.) sont disponibles. La plus ancienne porte le nom de AWT (A… Windowing Toolkit) et a jeté les bases du système de fenêtrage. Le système le plus récent est né d'une collaboration entre Sun et Netscape et porte le nom de SWING. Swing est une surcouche posée sur AWT (la plupart des classes de Swing dérivent des classes d'AWT) qui apporte de nombreuses améliorations :

• Richesse fonctionnelle et de présentation supplémentaires
• Nouveau modèle de gestion des événements
• Modèle Document / Instance pour la création de composants
• Modèle Document / Vue pour les composants d'affichage de données

Les bases de construction d'une interface graphique

Une interface graphique est basée sur 2 grandes composantes différentes :

• L'aspect visuel qui comprend les cadres et les composants d'interfaces qui sont placés dessus
• L'interaction avec les utilisateurs (action de la souris, du clavier) c'est à dire en fait la gestion des événements.

La programmation visuelle s'appuye sur le concept de fenêtre cher aux environnements modernes. Toute programmation graphique s'appuie sur un conteneur global. Celui-ci peut être :

• Une fenêtre cadre
• Une fenêtre de dialogue
• Une applet

Les deux premiers types sont assez semblables car ils sont généraux à tout type de système fenêtré. Par exemple, sous Windows, une fenêtre cadre correspond à la fenêtre principale d'une application.

Les composants visuels

Les composants

Tout composant visuel descend plus ou moins directement de la classe

La gestion des événements

Les événements sont des objets spéciaux qui sont générés par les actions de l'utilisateur (un clic de souris par exemple) ou par le système lui même (une défaillance du système de fichier). Par défaut, ils sont placés dans la file d'événements (events queue). Certains événement sont gérés par le système lui même alors que les autres doivent être pris en compte par l'utilisateur. La file des messages a une taille limitée qui fait que les événements les plus anciens et qui n'ont pas été traités sont détruits afin de laisser la place aux événements les plus récents.

Il y a deux grands moyens pour gérer les événements :

1. Le programme va lui même pécher un événement dans la file et établit une réponse appropriée. Il a alors la possibilité de retirer l'événement s'il juge sa réponse suffisante ou bien de le laisser dans la file de manière à ce qu'il soit à nouveau géré par un mécanisme automatique du système.
2. Le programme met en place des objets spécialisés dits écouteurs d'événements spécialisés dans le traitement d'un type particulier d'événement (par exemple le déplacement de la souris) et associés à un élément d'interface précis (une fenêtre par exemple). Le système redirige alors les événements idoines vers une méthode particulière de l'objet.

Les listeners

Ce sont des objets spécialisés dans le traitement des événements. Comme explicité ci-dessus, ils doivent implémenter des interfaces particulières qui leur permettent de traiter les événements.

Chaque interface est associée à un grand type d'événements. Par exemple, l'interface java.awt.event.ActionListener correspond aux événements de type Commande (clicker sur un bouton, activer un menu etc.). Cette interface contient la méthode :

Cette méthode est destinée à être redéfinie dans la classe de votre objet Listener. Elle sera appelée automatiquement lorsque l'utilisateur cliquera sur un bouton par exemple. On ajoute un objet listener à un élément d'interface à l'aide d'unel méthode addXXXListener ou XXX dénote le type d'événement traité. Les élément suivants sont à prendre en compte :

• Un même objet peut répondre à différents types d'événements pour peu qu'il implémente les interfaces adéquates
• Un même objet peut être le listener de plusieurs sources
• Une même source peut avoir autant de listeners que de types d'événements qu'elle peut générer.
• On peut même connecter plusieurs listeners sur le même type d'événements de la même source. Ils seront appelés dans l'ordre inverse de leur ajout

Comme vous pouvez le voir dans l'exemple ci-dessus, les informations concernant l'événement sont passées au travers d'un objet dont la classe dérive de java.util.EventObject via java.awt.AWTEvent

La principale méthode des objets de type événement est sans nul doute :

qui renvoie une référence sur l'objet originaire de l'événement. Par exemple, le bouton qui a été cliqué dans l'exemple précédent.

Toutes les interfaces de gestion des événements ne sont pas aussi simples que ActionListener. Ainsi, WindowListener, qui, comme son nom l'indique est l'interface associée aux événements concernant les fenêtres ne compte pas moins de 7 méthodes à implémenter, chacune d'entre elles couplée à un événement de la « vie » d'une fenêtre : ouverture, activation, tentative de fermeture, fermeture, iconification, restauration.

Cela signifie t'il que vous deviez fournir du code pour chacune des méthodes de l'interface même si vous n'êtes intéressé que par un seul événement ? Les concepteurs de l'AWT ont proposé une méthode alternative à l'implémentation directe de l'interface WindowsListener en créant pour vous la classe WindowAdapter qui elle même fournit une implémentation triviale de l'interface WindowListener où chaque méthode est réduite à la plus simple expression.

Ainsi, si vous souhaitez ne répondre qu'à un nombre limité d'éléments, il vous suffit de dériver votre classe Listener de WindowsAdapter et de redéfinir uniquement les méthodes qui vous intéressent. L'exemple classique concerne la fermeture d'une fenêtre.

En effet, considérez le simple programme suivant :

Si vous cliquez sur le bouton de fermeture de la fenêtre, celle-ci disparaît effectivement de l'écran mais l'application n'est pas fermée pour autant. Si vous souhaitez acquérire ce comportement standard, il vous faut mettre un terme à l'application dans un listener associé à l'évènement windowClosing.

Vous pouvez le faire dans un objet séparé :

Mais, le plus souvent, vous utiliserez ici un objet anonyme, comme dans l'exemple suivant :

La classe WindowAdapter est dérivée à la volée et l'objet créé instantanément et de façon anonyme.