Interfaces graphiques

JFrame représente une fenêtre. Ses principales propriétés sont : son titre (title), sa taille et sa position à l'écran (bounds), sa visibilité (visible, valant false par défaut), son comportement en cas de fermeture (defaultCloseOperation) et son panneau de contenu (contentPane).

Par défaut, lorsque l'utilisateur ferme une fenêtre, celle-ci est simplement rendue invisible. Ce comportement est souvent inadéquat pour la fenêtre principale d'une application, car il est préférable que la fermeture de cette fenêtre provoque l'arrêt complet de l'application, p.ex. via un appel à System.exit. Pour obtenir ce comportement, on peut changer la propriété defaultCloseOperation afin de lui donner la valeur EXIT_ON_CLOSE :

JFrame f = …;
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Comme cela sera expliqué plus loin, l'agencement des composants à l'écran est généralement fait automatiquement dans une application Swing. Cet agencement se fait récursivement, en commençant par les feuilles puis en remontant jusqu'à la racine. Les composants de niveau supérieur offrent une méthode pack permettant d'agencer tous les composants de la hiérarchie dont ils constituent la racine.

JDialog représente une boîte de dialogue, visuellement similaire à une fenêtre mais se comportant différemment. Une boîte de dialogue est toujours liée à une fenêtre existante, dans le sens où lorsque cette dernière est fermée ou iconifiée, il en va de même de la première.

Beaucoup de boîtes de dialogue sont modales (modal), dans le sens où toute interaction avec le reste de l'application est impossible tant et aussi longtemps que la boîte n'est pas fermée.

Les conteneurs de niveau supérieur ne contiennent pas directement un certain nombre de composants fils. Au lieu de cela, ils possèdent un unique panneau racine (root pane), un type spécial de conteneur intermédiaire.

Ce panneau racine contient, entre autres, un panneau de contenu (content pane), dans lequel les composants spécifiques à l'application sont ajoutés. La plupart des applications ignorent donc le panneau racine et interagissent uniquement avec le panneau de contenu.

Le panneau de contenu est une propriété modifiable des conteneurs de niveau supérieur, nommée contentPane.

JSplitPane permet de diviser le composant en deux parties, chacune affichant un composant fils. La division peut être verticale ou horizontale, et est redimensionnable, éventuellement par l'utilisateur.

JTabbedPane est un panneau composé d'un certain nombre d'onglets affichant chacun un composant fils différent. Un seul onglet est visible à un instant donné.

JScrollPane donne accès à une sous-partie d'un composant trop grand pour tenir à l'écran et permet de déplacer la zone visualisée de différentes manières, p.ex. au moyen de barres de défilement.

JLayeredPane permet de superposer plusieurs composants, ce qui peut être utile pour dessiner au-dessus de composants existants ou pour intercepter les clics de souris qui leur sont destinés.

JPanel représente un panneau, un conteneur intermédiaire sans représentation graphique propre — exception faite de son éventuelle bordure, voir plus loin — et pouvant avoir un nombre quelconque de fils. Malgré son invisibilité, JPanel joue un rôle fondamental dans l'organisation des interfaces, de par sa capacité à grouper et placer — via son gestionnaire d'agencement — d'autres composants.

Les méthodes add et remove permettent de gérer les fils d'un conteneur JPanel :

• void add(JComponent c, Object l, int i) : insère le composant c à la position i dans les fils (-1 signifiant la fin) et lui associe l'information d'agencement l (voir plus loin),
• void add(JComponent c, Object l) équivaut à add(c, l, -1)
• void add(JComponent c) équivaut à add(c, null)
• void remove(JComponent c) : supprime le composant c des fils,
• void remove(int i) : supprime le fils d'index i.

Tout composant fils d'un panneau occupe un rectangle imbriqué dans celui de son parent. On nomme bornes (bounds) la position (x, y) et la taille (width, height) de ce rectangle, exprimés dans le repère du panneau.

L'agencement des fils — leur positionnement à l'intérieur du rectangle de leur parent — peut se faire de deux manières :

1. « manuellement », en changeant leurs bornes au moyen de la méthode setBounds,
2. via un gestionnaire d'agencement (layout manager) attaché au parent et responsable de l'agencement de ses fils et de son dimensionnement.

Dans la quasi-totalité des cas, la seconde solution est choisie.

Les gestionnaires d'agencement peuvent utiliser plusieurs caractéristiques des composants fils pour les placer :

• leur index dans la séquence des fils,
• leur taille minimale (propriété minimumSize), préférée (preferredSize) et maximale (maximumSize),
• l'éventuelle information d'agencement qui leur a été associée au moment de leur ajout via la méthode add.

Attention : les gestionnaires ont le droit, mais pas l'obligation, d'utiliser ces caractéristiques. En particulier, plusieurs gestionnaires ignorent totalement les informations de taille.

L'interface LayoutManager représente un gestionnaire d'agencement. Un certain nombre de gestionnaires prédéfinis l'implémentant sont fournis avec Swing : FlowLayout, BorderLayout, GridLayout, GridBagLayout, etc. Ces gestionnaires agencent chacun les fils en fonction d'une technique qui leur est propre.

BorderLayout découpe le composant en cinq régions nommées, chacune d'entre elles pouvant contenir au plus un composant.

Toutes les zones sauf la centrale sont dimensionnées en fonction de leur contenu — qui peut être inexistant. La totalité de l'espace restant est attribué à la zone centrale.

FlowLayout place les fils de la même manière que les mots d'un texte sont arrangés en lignes successives.

Cet agencement peut se faire de gauche à droite ou de droite à gauche, et les lignes peuvent être alignées à gauche, à droite, ou centrées. Les fils sont séparés horizontalement et verticalement par un espacement configurable. Par exemple, il peut agencer six fils d'un panneau en les plaçant de gauche à droite et en centrant chaque ligne, comme sur la figure 12.

BoxLayout place les fils dans l'ordre, soit alignés horizontalement, soit empilés verticalement. Par exemple, il peut agencer trois fils d'un panneau en les empilant verticalement, comme sur la figure 13.

GridLayout place les fils dans une grille de n×m cellules de taille identique, en partant du coin haut-gauche et en suivant le sens de lecture. Par exemple, il peut agencer neuf fils d'un panneau dans une grille de 3×3 cellules, comme sur la figure 14.

Swing offre encore d'autres gestionnaires d'agencement, plus puissants que ceux présentés jusqu'ici, parmi lesquels :

• GridBagLayout, version améliorée de GridLayout permettant de dimensionner les lignes et colonnes individuellement, et de combiner des cellules,
• GroupLayout, associant chaque composant à un groupe horizontal et un groupe vertical et alignant de manière configurable tous les composants d'un groupe.

Malheureusement, comme tous les gestionnaires d'agencement offerts par Swing, ils montrent assez vite leurs limites lors de la construction d'interfaces complexes.

L'interface de la calculatrice peut être mise en page au moyen de deux gestionnaires :

• le premier de type BorderLayout, attaché au panneau de contenu, permettant de placer l'affichage dans la zone PAGE_START et le panneau du clavier dans la zone CENTER,
• le second de type GridLayout et de taille 4×4, attaché au panneau clavier.

Le code correspondant est le suivant :

JPanel p = new JPanel(new BorderLayout());
JFormattedTextField display = …;
// … configuration de display
p.add(display, BorderLayout.PAGE_START);

JPanel keyboard = new JPanel(new GridLayout(4, 4));
// … configuration de keyboard (boutons, …)
p.add(keyboard, BorderLayout.CENTER);

JFrame frame = new JFrame("RPN Calc");
frame.setContentPane(p);

JLabel représente l'un des composants les plus simples qui soit, une étiquette textuelle et/ou graphique. Ses principales propriétés sont le texte (text) et l'image (icon) qu'elle affiche, pouvant les deux être vides (null).

La figure 16 illustre l'utilisation de trois étiquettes (Nom, Prénom et Age) dans un formulaire.

JButton représente un bouton à un état, destiné à être cliqué pour effectuer une action. Sa principale propriété est le texte qu'il affiche (text). Des auditeurs peuvent lui être attachés pour gérer les clics de l'utilisateur — voir plus loin.

JCheckBox représente une case à cocher, qui peut être sélectionnée ou non. Ses principales propriétés sont le texte qu'elle affiche (text) et son état (selected).

JRadioButton représente un bouton « radio », similaire à une case à cocher mais faisant partie d'un groupe (de type ButtonGroup) dont un seul peut être sélectionné. Ses principales propriétés sont les mêmes que celles de JCheckBox.

JComboBox représente une « combo box » permettant de choisir une valeur parmi un ensemble prédéfini et éventuellement d'en entrer une autre.

JTextField et ses sous-classes JFormattedTextField et JPasswordField représentent des champs textuels à une ligne et à présentation uniforme (police unique, etc.). Leur principale propriété est leur texte (text), une simple chaîne de caractères de type String.

JFormattedTextField stocke une valeur non textuelle dans sa propriété value et la transforme en texte (et inversement) au moyen d'un formateur qui lui est attaché.

JTextArea est similaire à JTextField mais permet les lignes multiples, tandis que JTextPane et JEditorPane permettent l'affichage — et éventuellement l'édition — de texte mis en page. Leur principale propriété est le texte qu'ils contiennent (text), également disponible en version mise en page (document).

JProgressBar représente une barre de progression, permettant de visualiser l'état d'avancement d'une opération de longue durée. Sa principale propriété est sa valeur (value), un entier compris entre 0 et une valeur maximale choisie, indiquant l'état d'avancement actuel.

En plus des composants de base « simples » décrits précédemment, Swing offre des macro-composants souvent utiles, construits à partir des composants de base :

• JColorChooser, qui permet de choisir une couleur de différentes manières (via une palette, en choisissant ses composantes dans différents modèles, etc.),
• JFileChooser, qui permet de choisir un ou plusieurs fichiers ou répertoires, existants ou non, en naviguant dans le système de fichiers.

Ces deux macro-composants peuvent s'utiliser comme des composants normaux ou dans des boîtes de dialogue.

Finalement, Swing offre des composants permettant d'afficher des données structurées : listes, tableaux, hiérarchie arborescente. Ces composants sont plus complexes à utiliser que les autres étant donné la nature des données qu'ils affichent. Pour les obtenir, ces composants utilisent un modèle qu'on leur fournit.

Plusieurs composants de base permettent d'afficher et de manipuler des données complexes, par exemple :

• JList affiche une liste d'éléments,
• JTree affiche une hiérarchie arborescente,
• JTable affiche une table bidimensionnelle de cellules,
• etc.

Où stocker les données affichées par ces composants et quel type leur attribuer ?

Une solution serait de stocker les données directement dans les composants. Par exemple, le composant JList pourrait stocker la liste des éléments qu'il affiche. Cette solution est mauvaise car elle va à l'encontre de la séparation conseillée par le patron MVC : les données à afficher font partie du modèle et ne doivent donc pas être stockée dans la vue.

Une meilleure solution est de faire en sorte que les composants puissent directement utiliser les données du modèle.

Pour ce faire, Swing offre la possibilité d'attacher à chacun des composants complexes précités un objet appelé modèle (model) et représentant les données sous-jacentes. Ce modèle doit être observable au sens du patron Observer pour permettre au composant de se mettre à jour automatiquement. Le type de ces modèles est spécifié par des interfaces fournies par Swing, et il est donc généralement nécessaire d'écrire un adaptateur pour adapter les données du programme aux types attendus par Swing.

Par exemple, le composant JList affiche une liste d'éléments et permet leur sélection. Il doit donc pouvoir effectuer les opérations suivantes sur la liste à afficher :

• obtenir sa taille,
• obtenir l'élément d'indice donné,
• observer la liste pour être informé des changements.

Ces opérations sont regroupées dans l'interface ListModel, représentant un modèle de liste.

L'interface ListModel offre d'une part des méthodes permettant de gérer l'ensemble des observateurs — appelés ici auditeurs (listeners) — et d'autre part des méthodes de consultation de la liste de valeurs.

public interface ListModel<E> {
  void addListDataListener(ListDataListener l);
  void removeListDataListener(ListDataListener l);

  int getSize();
  E getElementAt(int i);
}

Pour faciliter l'écriture de modèles de listes, Swing offre la classe AbstractListModel qui met en œuvre les méthodes gérant les auditeurs, laissant uniquement les méthodes getSize et getElementAtIndex abstraites. Cette classe fournit de plus des méthodes dont le nom commence par fire… et permettant d'informer les auditeurs de changements dans le modèle — similaires à la méthode notifyObservers des sujets du patron Observer.

L'interface ListDataListener représente un observateur de modèle de liste, appelé ici auditeur.

public interface ListDataListener {
  void intervalAdded(ListDataEvent e);
  void intervalRemoved(ListDataEvent e);
  void contentsChanged(ListDataEvent e);
}

Plutôt qu'une unique méthode de mise à jour (update), il en possède trois. La dernière est générale, tandis que les deux premières représentent des cas particuliers — ajout et suppression d'éléments — qui ont été jugés assez fréquents pour valoir la peine d'être traités séparément.

La classe ListDataEvent contient les informations liées au changement du contenu de la liste observée, à savoir :

• le type de changement — ajout d'un intervalle, suppression d'un intervalle, changement général,
• l'index du premier élément affecté par le changement,
• l'index du dernier élément affecté par le changement.

Le diagramme de classes de la figure 25 illustre — de manière légèrement simplifiée — les classes qui seraient utilisées par une application incluant un composant JList.

L'interface (fonctionnelle) ActionListener représente un auditeur à l'écoute des événements de type « action ». Ces événements se produisent p.ex. lorsque l'utilisateur clique sur un bouton, sélectionne un menu ou presse Entrée dans un champ textuel.

public interface ActionListener {
  void actionPerformed(ActionEvent e);
}

La classe ActionEvent contient différentes informations au sujet de l'événement, p.ex. les touches de modifications (Control, Shift, …) pressées au moment du déclenchement de l'action.

Un auditeur de type ActionListener peut être attaché à plusieurs types de composants, principalement les boutons, les champs textuels et les entrées de menus. Chacun de ces types de composants offre les méthodes addActionListener et removeActionListener pour ajouter/supprimer un auditeur d'action.

L'interface MouseListener représente un auditeur à l'écoute de certains événements liés à la souris : entrée et sortie des bornes du composant, pression et relâchement des boutons :

public interface MouseListener {
  void mouseEntered(MouseEvent e);
  void mouseExited(MouseEvent e);
  void mouseClicked(MouseEvent e);
  void mousePressed(MouseEvent e);
  void mouseReleased(MouseEvent e);
}

La classe MouseEvent contient différentes informations concernant l'événement, p.ex. la position de la souris.

L'interface MouseMotionListener représente un auditeur à l'écoute des événements liés au déplacement de la souris, avec un bouton pressé (mouseDragged) ou non (mouseMoved) :

public interface MouseMotionListener {
  void mouseDragged(MouseEvent e);
  void mouseMoved(MouseEvent e);
}

Chaque mouvement de la souris constituant un nouvel événement, ceux-ci peuvent être très nombreux. Les auditeurs de type MouseMotionListener se doivent donc de traiter rapidement les événements.

L'interface (fonctionnelle) MouseWheelListener représente un auditeur à l'écoute des événements liés à la molette de la souris :

public interface MouseWheelListener {
  void mouseWheelMoved(MouseWheelEvent e);
}

La classe MouseWheelEvent étend MouseEvent en lui ajoutant des informations liées à la molette : distance et sens de rotation, etc.

Les trois types d'auditeurs liés à la souris peuvent être attachés à (et détachés de) n'importe quel composant au moyen des méthodes addMouse…Listener et removeMouse…Listener.

La classe héritable MouseAdapter fournit une mise en œuvre par défaut des interfaces MouseListener, MouseMotionListener et MouseWheelListener. Elle implémente la totalité des méthodes de ces interfaces, en ne faisant rien dans tous les cas.

Attention : malgré son nom, cette classe n'est pas un adaptateur au sens du patron Adapter. Un nom plus conforme aux conventions généralement utilisées dans la bibliothèque Java serait AbstractMouseListener.