précédentsommairesuivant

XV. Création de fenêtres et d'applets

Une directive de conception fondamentale est « rendre les choses simples faciles, et les choses difficiles possibles ».

L'objectif initial de la conception de la bibliothèque d'interface utilisateur graphique [graphical user interface (GUI)] en Java 1.0 était de permettre au programmeur de construire une GUI qui a un aspect agréable sur toutes les plateformes. Ce but n'a pas été atteint. L'Abstract Window Toolkit (AWT) de Java 1.0 produit au contraire une GUI d'aspect aussi médiocre sur tous les systèmes. De plus, elle est restrictive : on ne peut utiliser que quatre fontes, et on n'a accès à aucun des éléments de GUI sophistiqués disponibles dans son système d'exploitation.Le modèle de programmation de l'AWT Java 1.0 est aussi maladroit et non orienté objet. Un étudiant d'un de mes séminaires (qui était chez Sun lors de la création de Java) m'a expliqué pourquoi : l'AWT original avait été imaginé, conçu, et implémenté en un mois. Certainement une merveille de productivité, mais aussi un exemple du fait que la conception est importante.

La situation s'est améliorée avec le modèle d'événements de l'AWT de Java 1.1, qui a une approche beaucoup plus claire et orientée objet, avec également l'ajout des JavaBeans, un modèle de programmation par composants qui est tourné vers la création facile d'environnements de programmation visuels. Java 2 termine la transformation depuis l'ancien AWT de Java 1.0 en remplaçant à peu près tout par les Java Foundation Classes (JFC), dont la partie GUI est appelée « Swing ». Il s'agit d'un ensemble riche de JavaBeans faciles à utiliser et faciles à comprendre, qui peuvent être glissés et déposés (ou programmés manuellement) pour créer une GUI qui vous donnera (enfin) satisfaction. La règle de la « version 3 » de l'industrie du logiciel (un produit n'est bon qu'à partir de la version 3) semble également se vérifier pour les langages de programmation.

Ce chapitre ne couvre que la bibliothèque moderne Swing de Java 2, et fait l'hypothèse raisonnable que Swing est la bibliothèque finale pour les GUI Java. Si pour une quelconque raison vous devez utiliser le « vieux » AWT d'origine (parce que vous maintenez du code ancien ou que vous avez des limitations dans votre browser), vous pouvez trouver cette présentation dans la première édition de ce livre, téléchargeable à www.BruceEckel.com (également incluse sur le CD-ROM fourni avec ce livre).

Dès le début de ce chapitre, vous verrez combien les choses sont différentes selon que vous voulez créer une applet ou une application normale utilisant Swing, et comment créer des programmes qui sont à la fois des applets et des applications, de sorte qu'ils puissent être exécutés soit dans un browser soit depuis la ligne de commande. Presque tous les exemples de GUI seront exécutables aussi bien comme des applets que comme des applications.

Soyez conscients que ceci n'est pas un glossaire complet de tous les composants Swing, ou de toutes les méthodes pour les classes décrites. Ce qui se trouve ici a pour but d'être simple. La bibliothèque Swing est vaste, et le but de ce chapitre est uniquement de vous permettre de démarrer avec les notions essentielles et d'être à l'aise avec les concepts. Si vous avez besoin de plus, alors Swing peut probablement vous donner ce que vous voulez si vous avez la volonté de faire des recherches.

Je suppose ici que vous avez téléchargé et installé les documents (gratuits) de la bibliothèque Java au format HTML depuis java.sun.com et que vous parcourrez les classes javax.swing dans cette documentation pour voir tous les détails et toutes les méthodes de la bibliothèque Swing. Grâce à la simplicité de la conception de Swing, ceci sera souvent suffisant pour régler votre problème. Il y a de nombreux livres (assez épais) dédiés uniquement à Swing et vous vous y référerez si vous avez besoin d'approfondir, ou si vous voulez modifier le comportement par défaut de Swing.

En apprenant Swing vous découvrirez que :

  1. Swing est un bien meilleur modèle de programmation que ce que vous avez probablement vu dans d'autres langages et environnements de développement. Les JavaBeans (qui seront présentées vers la fin de ce chapitre) constituent l'ossature de cette bibliothèque ;
  2. Les « GUI builders »(environnements de programmation visuels) sont un must-have d'un environnement de développement Java complet. Les JavaBeans et Swing permettent au « builder » d'écrire le code pour vous lorsque vous placez les composants sur des formulaires à l'aide d'outils graphiques. Ceci permet non seulement d'accélérer le développement lors de la création de GUI, mais aussi d'expérimenter plus et de ce fait d'essayer plus de modèles et probablement d'en obtenir un meilleur ;
  3. La simplicité et la bonne conception de Swing signifie que même si vous utilisez un GUI builder plutôt que du codage manuel, le code résultant sera encore compréhensible ; ceci résout un gros problème qu'avaient les GUI builders, qui généraient souvent du code illisible.

Swing contient tous les composants attendus dans une interface utilisateur moderne, depuis des boutons contenant des images jusqu'à des arborescences et des tables. C'est une grosse bibliothèque, mais elle est conçue pour avoir la complexité appropriée pour la tâche à effectuer ; si quelque chose est simple, vous n'avez pas besoin d'écrire beaucoup de code, mais si vous essayez de faire des choses plus compliquées, votre code devient proportionnellement plus complexe. Ceci signifie qu'il y a un point d'entrée facile, mais que vous avez la puissance à votre disposition si vous en avez besoin.

Ce que vous aimerez dans Swing est ce qu'on pourrait appeler l'« orthogonalité d'utilisation ». C'est-à-dire, une fois que vous avez compris les idées générales de la bibliothèque, vous pouvez les appliquer partout. Principalement grâce aux conventions de nommage standards, en écrivant ces exemples je pouvais la plupart du temps deviner le nom des méthodes et trouver juste du premier coup, sans rechercher quoi que ce soit. C'est certainement la marque d'une bonne conception de la bibliothèque. De plus, on peut en général connecter des composants entre eux et les choses fonctionnent correctement.

Pour des questions de rapidité, tous les composants sont « légers » , et Swing est écrit entièrement en Java pour la portabilité.

La navigation au clavier est automatique ; vous pouvez exécuter une application Swing sans utiliser la souris, et ceci ne réclame aucune programmation supplémentaire. Le scrolling se fait sans effort, vous emballez simplement votre composant dans un JScrollPane lorsque vous l'ajoutez à votre formulaire. Des fonctionnalités telles que les « infobulles » [tool tips] ne demandent qu'une seule ligne de code pour les utiliser.

Swing possède également une fonctionnalité assez avancée, appelée le « pluggable look and feel », qui signifie que l'apparence de l'interface utilisateur peut être modifiée dynamiquement pour s'adapter aux habitudes des utilisateurs travaillant sur des plateformes et systèmes d'exploitation différents. Il est même possible (quoique difficile) d'inventer son propre « look and feel ».

XV-A. L'applet de base

Un des buts de la conception Java est de créer des applets, qui sont des petits programmes s'exécutant à l'intérieur d'un browser Web. Parce qu'elles doivent être sûres, les applets sont limitées dans ce qu'elles peuvent accomplir. Toutefois, les applets sont un outil puissant de programmation côté client, un problème majeur pour le Web.

XV-A-1. Les restrictions des applets

Programmer dans une applet est tellement restrictif qu'on en parle souvent comme étant « dans le bac à sable », car il y a toujours quelqu'un (le système de sécurité Java lors de l'exécution [Java run-time security system] ) qui vous surveille.

Cependant, on peut aussi sortir du bac à sable et écrire des applications normales plutôt que des applets ; dans ce cas on accède aux autres fonctionnalités de son OS. Nous avons écrit des applications tout au long de ce livre, mais il s'agissait d'applications console, sans aucun composant graphique. Swing peut aussi être utilisé pour construire des interfaces utilisateur graphiques pour des applications normales.

On peut en général répondre à la question de savoir ce qu'une applet peut faire en considérant ce qu'elle est supposée faire : étendre les fonctionnalités d'une page Web dans un browser. Comme en tant que surfeur sur le Net on ne sait jamais si une page Web vient d'un site amical ou pas, on veut que tout le code qu'il exécute soit sûr. De ce fait, les restrictions les plus importantes sont probablement :

  1. Une applet ne peut pas toucher au disque local. Ceci signifie écrire ou lire, puisqu'on ne voudrait pas qu'une applet lise et transmette des informations privées sur Internet sans notre permission. Écrire est interdit, bien sûr, car ce serait une invitation ouverte aux virus. Java permet une signature digitale des applets. Beaucoup de restrictions des applets sont levées si on autorise des applets de confiance [trusted applets] (celles qui sont signées par une source dans laquelle on a confiance) à accéder à sa machine ;
  2. Les applets peuvent mettre du temps à s'afficher, car il faut les télécharger complètement à chaque fois, nécessitant un accès au serveur pour chacune des classes. Le browser peut mettre l'applet dans son cache, mais ce n'est pas garanti. Pour cette raison, on devrait toujours empaqueter ses applets dans un fichier JAR (Java ARchive) qui rassemble tous les composants de l'applet (y compris d'autres fichiers .class ainsi que les images et les sons) en un seul fichier compressé qui peut être téléchargé en une seule transaction avec le serveur. La « signature digitale » existe pour chacun des fichiers contenus dans le fichier JAR.

Les avantages d'une applet

Si on admet ces restrictions, les applets ont des avantages, en particulier pour la création d'applications client/serveur ou réseaux :

  1. Il n'y a pas de problème d'installation. Une applet est réellement indépendante de la plateforme (y compris pour jouer des fichiers audio, etc.) et donc il n'est pas nécessaire de modifier le code en fonction des plateformes ni d'effectuer des « réglages » à l'installation. En fait, l'installation est automatique chaque fois qu'un utilisateur charge la page Web qui contient les applets, de sorte que les mises à jour se passent en silence et automatiquement. Dans les systèmes client/serveur traditionnels, créer et installer une nouvelle version du logiciel client est souvent un cauchemar ;
  2. On ne doit pas craindre un code défectueux affectant le système de l'utilisateur, grâce au système de sécurité inclus au cœur du langage Java et de la structure de l'applet. Ceci, ainsi que le point précédent, rend Java populaire pour les applications intranet client/serveur qui n'existent qu'à l'intérieur d'une société ou dans une zone d'opérations réduite, où l'environnement utilisateur (le navigateur Web et ses extensions) peut être spécifié et/ou contrôlé.

Comme les applets s'intègrent automatiquement dans le code HTML, on dispose d'un système de documentation intégré et indépendant de la plateforme pour le support de l'applet. C'est une astuce intéressante, car on a plutôt l'habitude d'avoir la partie documentation du programme plutôt que l'inverse.

XV-A-3. Les squelettes d'applications

Les bibliothèques sont souvent groupées selon leurs fonctionnalités. Certaines bibliothèques, par exemple, sont utilisées telles quelles. Les classes String et ArrayList de la bibliothèque standard Java en sont des exemples. D'autres bibliothèques sont conçues comme des briques de construction pour créer d'autres classes. Une certaine catégorie de bibliothèques est le squelette d'applications [application framework], dont le but est d'aider à la construction d'applications en fournissant une classe ou un ensemble de classes reproduisant le comportement de base dont vous avez besoin dans chaque application d'un type donné. Ensuite, pour particulariser le comportement pour ses besoins propres, on hérite de la classe et on redéfinit les méthodes qui nous intéressent. Un squelette d'application est un bon exemple de la règle « séparer ce qui change de ce qui ne change pas », car on essaie de localiser les parties spécifiques d'un programme dans les méthodes redéfinies (49)

les applets sont construites à l'aide d'un squelette d'application. On hérite de la classe JApplet et on redéfinit les méthodes adéquates. Quelques méthodes contrôlent la création et l'exécution d'une applet dans une page Web :

Method Operation
init() Appelée automatiquement pour effectuer la première initialisation de l'applet, y compris la disposition des composants. Il faut toujours redéfinir cette méthode.
start() Appelée chaque fois que l'applet est rendue visible du navigateur Web, pour permettre à l'applet de démarrer ses opérations normales (en particulier celles qui sont arrêtées par stop()). Appelée également après init().
stop() Appelée chaque fois que l'applet redevient invisible du navigateur Web, pour permettre à l'applet d'arrêter les opérations coûteuses. Appelée également juste avant destroy().
destroy() Appelée lorsque l'applet est déchargée de la page pour effectuer la libération finale des ressources lorsque l'applet n'est plus utilisée.

Avec ces informations nous sommes prêts à créer une applet simple :

 
Sélectionnez
//: c13:Applet1.java
// Très simple applet.
import javax.swing.*;
import java.awt.*;

public class Applet1 extends JApplet {
  public void init() {
  getContentPane().add(new JLabel("Applet!"));
}
} ///:~

Remarquons qu'il n'est pas obligatoire qu'une applet ait une méthode main(). C'est complètement câblé dans le squelette d'application ; on met tout le code de démarrage dans init().

Dans ce programme, la seule activité consiste à mettre un label de texte sur l'applet, à l'aide de la classe JLabel (l'ancien AWT s'était approprié le nom Label ainsi que quelques autres noms de composants, de sorte qu'on verra souvent un « J » au début des composants Swing). Le constructeur de cette classe reçoit une String et l'utilise pour créer le label. Dans le programme ci-dessus ce label est placé dans le formulaire.

La méthode init() est responsable du placement de tous les composants du formulaire en utilisant la méthode add(). On pourrait penser qu'il devrait être suffisant d'appeler simplement add(), et c'est ainsi que cela se passait dans l'ancien AWT. Swing exige quant à lui qu'on ajoute tous les composants sur la « vitre de contenu » [content pane] d'un formulaire, et il faut donc appeler getContentPane() au cours de l'opération add().

XV-A-4. Exécuter des applets dans un navigateur Web

Pour exécuter ce programme, il faut le placer dans une page Web et visualiser cette page à l'aide d'un navigateur Web configuré pour exécuter des applets Java. Pour placer une applet dans une page Web, on place un tag spécial dans le source HTML de cette page (50) pour dire à la page comment charger et exécuter cette applet.

Ce système était très simple lorsque Java lui-même était simple et que tout le monde était dans le même bain et incorporait le même support de Java dans les navigateurs Web. Il suffisait alors d'un petit bout de code HTML dans une page Web, tel que :

 
Sélectionnez
<applet code=Applet1 width=100 height=50>
</applet>

Ensuite vint la guerre des navigateurs et des langages, et nous (programmeurs aussi bien qu'utilisateurs finals) y avons perdu. Au bout d'un moment, JavaSoft s'est rendu compte qu'on ne pouvait plus supposer que les navigateurs supportaient la version correcte de Java, et que la seule solution était de fournir une sorte d'extension qui se conformerait au mécanisme d'extension des navigateurs. En utilisant ce mécanisme d'extensions (qu'un fournisseur de navigateur ne peut pas supprimer - dans l'espoir d'y gagner un avantage sur la concurrence - sans casser aussi toutes les autres extensions), JavaSoft garantit que Java ne pourra pas être supprimé d'un navigateur Web par un fournisseur qui y serait hostile.

Avec Internet Explorer, le mécanisme d'extensions est le contrôle ActiveX, et avec Netscape c'est le plug-in. Dans le code HTML, il faut fournir les tags qui supportent les deux. Voici à quoi ressemble la page HTML la plus simple pour Applet1 : (51)

 
Sélectionnez
//:! c13:Applet1.html
<html><head><title>Applet1</title></head><hr>
<OBJECT 
classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"
width="100" height="50" align="baseline"&#160;&#160;codebase="http://java.sun.com/products/plugin/1.2.2/jinstall-1_2_2-win.cab#Version=1,2,2,0">
<PARAM NAME="code" VALUE="Applet1.class">
<PARAM NAME="codebase" VALUE=".">
<PARAM NAME="type" VALUE="application/x-java-applet;version=1.2.2">
<COMMENT>
<EMBED type=&#160;&#160;"application/x-java-applet;version=1.2.2" 
&#160;&#160;width="200" height="200" align="baseline"
&#160;&#160;code="Applet1.class" codebase="."
pluginspage="http://java.sun.com/products/plugin/1.2/plugin-install.html">
<NOEMBED>
</COMMENT>
No Java 2 support for APPLET!!
</NOEMBED>
</EMBED>
</OBJECT>
<hr></body></html>
///:~

Certaines de ces lignes étaient trop longues et ont été coupées pour être insérées dans cette page. Le code inclus dans les sources de ce livre (sur le CD-ROM de ce livre, et téléchargeable sur www.BruceEckel.com) fonctionne sans qu'on doive s'occuper de corriger les sauts de lignes.

Le contenu de code fournit le nom du fichier .class dans lequel se trouve l'applet. Les paramètres width et height spécifient la taille initiale de l'applet (en pixels, comme avant). Il y a d'autres éléments qu'on peut placer dans le tag applet : un endroit où on peut trouver d'autres fichiers .class sur Internet (codebase), des informations d'alignement (align), un identificateur spécial permettant à des applets de communiquer entre eux (name), et des paramètres des applets pour fournir des informations que l'applet peut récupérer. Les paramètres sont de la forme :

 
Sélectionnez
<param name="identifier" value = "information">

et il peut y en avoir autant qu'on veut.

Le package de codes source de ce livre fournit une page HTML pour chacune des applets de ce livre, et de ce fait de nombreux exemples du tag applet. Vous pouvez trouver une description complète et à jour des détails concernant le placement d'applets dans des pages web à l'adresse java.sun.com.

XV-A-5. Utilisation de Appletviewer

Le JDK de Sun (en téléchargement libre depuis java.sun.com) contient un outil appelé l'Appletviewer qui extrait le tag du fichier HTML et exécute les applets sans afficher le texte HTML autour. Comme l'Appletviewer ignore tout ce qui n'est pas tags APPLET, on peut mettre ces tags dans le source Java en commentaires :

 
Sélectionnez
// <applet code=MyApplet width=200 height=100>
// </applet>

De cette manière, on peut lancer « appletviewer MyApplet.java » et il n'est pas nécessaire de créer de petits fichiers HTML pour lancer des tests. Par exemple, on peut ajouter ces tags HTML en commentaires dans Applet1.java :

 
Sélectionnez
//: c13:Applet1b.java
// Embedding the applet tag for Appletviewer.
// <applet code=Applet1b width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;

public class Applet1b extends JApplet {>
&#160;&#160;public void >init() {
&#160;&#160;getContentPane().add(new JLabel("Applet!"));
}
} ///:~

Maintenant on peut invoquer l'applet avec la commande

 
Sélectionnez
appletviewer Applet1b.java

XV-A-6. Tester les applets

On peut exécuter un test simple sans aucune connexion réseau en lançant son navigateur Web et en ouvrant le fichier HTML contenant le tag applet. Au chargement du fichier HTML, le navigateur découvre le tag applet et part à la recherche du fichier .class spécifié par le contenu de code. Bien sûr, il utilise le CLASSPATH pour savoir où chercher, et si le fichier .class n'est pas dans le CLASSPATH, il émettra un message d'erreur dans sa ligne de statut pour signaler qu'il n'a pas pu trouver le fichier .class.

Quand on veut essayer ceci sur son site Web les choses sont un peu plus compliquées. Tout d'abord il faut avoir un site Web, ce qui pour la plupart des gens signifie avoir un Fournisseur d'Accès à Internet (FAI) [Internet Service Provider (ISP)]. Comme l'applet est simplement un fichier ou un ensemble de fichiers, le FAI n'a pas besoin de fournir un support particulier pour Java. Il faut disposer d'un moyen pour copier les fichiers HTML et les fichiers .class depuis chez vous vers le bon répertoire sur la machine du FAI. Ceci est normalement fait avec un programme de File Transfer Protocol (FTP), dont il existe beaucoup d'exemples disponibles gratuitement ou comme sharewares. Il semblerait donc que tout ce qu'il y a à faire est d'envoyer les fichiers sur la machine du FAI à l'aide de FTP, et ensuite de se connecter au site et au fichier HTML en utilisant son navigateur ; si l'applet se charge et fonctionne, alors tout va bien, n'est-ce pas ?

C'est là qu'on peut se faire avoir. Si le navigateur de la machine client ne peut pas localiser le fichier .class sur le serveur, il va le rechercher à l'aide du CLASSPATH sur la machine locale. De ce fait l'applet pourrait bien ne pas se charger correctement depuis le serveur, mais tout paraît correct lors du test parce que le navigateur le trouve sur la machine locale. Cependant, lorsque quelqu'un d'autre se connecte, son navigateur ne la trouvera pas. Donc lorsque vous testez, assurez-vous d'effacer les fichiers .class (ou .jar) de votre machine locale pour vérifier qu'ils existent au bon endroit sur le serveur.

Un des cas les plus insidieux qui m'est arrivé s'est produit lorsque j'ai innocemment placé une applet dans un package. Après avoir téléchargé sur le serveur le fichier HTML et l'applet, le serveur fut trompé sur le chemin d'accès à l'applet à cause du nom du package. Cependant, mon navigateur l'avait trouvé dans le CLASSPATH local. J'étais donc le seul à pouvoir charger correctement l'applet. J'ai mis un certain temps à découvrir que l'instruction package était la coupable. En général il vaut mieux ne pas utiliser l'instruction package dans une applet.

XV-B. Exécuter des applets depuis la ligne de commande

Parfois on voudrait qu'un programme fenêtré fasse autre chose que se trouver dans une page Web. Peut-être voudrait-on aussi faire certaines des choses qu'une application « normale » peut faire, mais en gardant la glorieuse portabilité instantanée fournie par Java. Dans les chapitres précédents de ce livre, nous avons fait des applications de ligne de commande, mais dans certains environnements (le Macintosh par exemple) il n'y a pas de ligne de commande. Voilà un certain nombre de raisons pour vouloir construire un programme fenêtré n'étant pas une applet. C'est certainement un désir légitime.

La bibliothèque Swing nous permet de construire une application qui conserve le « look and feel » du système d'exploitation sous-jacent. Si vous voulez faire des applications fenêtrées, cela n'a de sens (52) que si vous pouvez utiliser la dernière version de Java et ses outils associés, afin de pouvoir fournir des applications qui ne perturberont pas vos utilisateurs. Si pour une raison ou une autre vous devez utiliser une ancienne version de Java, réfléchissez-y bien avant de vous lancer dans la construction d'une application fenêtrée importante.

On a souvent besoin de créer une classe qui peut être appelée aussi bien comme une fenêtre que comme une applet. C'est particulièrement utile lorsqu'on teste des applets, car il est souvent plus facile et plus simple de lancer l'applet-application depuis la ligne de commande que de lancer un navigateur Web ou l'Appletviewer.

Pour créer une applet qui peut être exécutée depuis la ligne de commande, il suffit d'ajouter un main() à l'applet, dans lequel on construit une instance de l'applet dans un JFrame (53). En tant qu'exemple simple, observons Applet1b.java modifié pour fonctionner aussi bien en tant qu'application qu'en tant qu'applet :

 
Sélectionnez
//: c13:Applet1c.java
// Une application et une applet.
// <applet code=Applet1c width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Applet1c extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;getContentPane().add(new JLabel("Applet!"));
}
&#160;&#160;// Un main() pour l'application :
&#160;&#160;public static void main(String[] args) {
&#160;&#160;JApplet applet = new Applet1c();
&#160;&#160;JFrame frame = new JFrame("Applet1c");
&#160;&#160; // Pour fermer l'application :
&#160;&#160;Console.setupClosing(frame);
&#160;&#160;frame.getContentPane().add(applet);
&#160;&#160;frame.setSize(100,50);
&#160;&#160;applet.init();
&#160;&#160;applet.start();
&#160;&#160;frame.setVisible(true);
}
} ///:~

main() est le seul élément ajouté à l'applet, et le reste de l'applet n'est pas modifié. L'applet est créée et ajoutée à un JFrame pour pouvoir être affichée.

La ligne :

 
Sélectionnez
Console.setupClosing(frame);

permet la fermeture propre de la fenêtre. Console vient de com.bruceeckel.swing et sera expliqué un peu plus tard.

On peut voir que dans main(), l'applet est explicitement initialisée et démarrée, car dans ce cas le navigateur n'est pas là pour le faire. Bien sûr, ceci ne fournit pas le comportement complet du navigateur, qui appelle aussi stop() et destroy(), mais dans la plupart des cas c'est acceptable. Si cela pose un problème, on peut forcer les appels soi-même href="#fn67">(54).

Notez la dernière ligne :

 
Sélectionnez
frame.setVisible(true);

Sans elle, on ne verrait rien à l'écran.

XV-B-1. Un squelette d'affichage

Bien que le code qui transforme des programmes en applets et applications produise des résultats corrects, il devient perturbant et gaspille du papier s'il est utilisé partout. Au lieu de cela, le squelette d'affichage ci-après sera utilisé pour les exemples Swing du reste de ce livre :

 
Sélectionnez
//: com:bruceeckel:swing:Console.java
// Outil pour exécuter des démos Swing depuis
// la console, aussi bien applets que JFrames.
package com.bruceeckel.swing;
import javax.swing.*;
import java.awt.event.*;

public class Console {
&#160;&#160;// Crée une chaîne de titre à partir du nom de la classe :
&#160;&#160;public static String title(Object o) {
&#160;&#160;String t = o.getClass().toString();
&#160;&#160; // Enlever le mot "class":
&#160;&#160; if(t.indexOf("class") != -1)
&#160;&#160;&#160;&#160;t = t.substring(6);
&#160;&#160; return t;
}
&#160;&#160;public static void setupClosing(JFrame frame) {
&#160;&#160; // La solution JDK 1.2 Solution avec une 
&#160;&#160; // classe interne anonyme :
&#160;&#160;frame.addWindowListener(new WindowAdapter() {
&#160;&#160;&#160;&#160;public void windowClosing(WindowEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;System.exit(0);
&#160;&#160;&#160;&#160;}
&#160;&#160;});
&#160;&#160; // La solution améliorée en JDK 1.3 :
&#160;&#160; // frame.setDefaultCloseOperation(
&#160;&#160; //&#160;&#160;&#160;&#160; EXIT_ON_CLOSE);
}
&#160;&#160;public static void 
run(JFrame frame, int width, int height) {
&#160;&#160;setupClosing(frame);
&#160;&#160;frame.setSize(width, height);
&#160;&#160;frame.setVisible(true);
}
&#160;&#160;public static void 
run(JApplet applet, int width, int height) {
&#160;&#160;JFrame frame = new JFrame(title(applet));
&#160;&#160;setupClosing(frame);
&#160;&#160;frame.getContentPane().add(applet);
&#160;&#160;frame.setSize(width, height);
&#160;&#160;applet.init();
&#160;&#160;applet.start();
&#160;&#160;frame.setVisible(true);
}
&#160;&#160;public static void 
run(JPanel panel, int width, int height) {
&#160;&#160;JFrame frame = new >JFrame(title(panel));
&#160;&#160;setupClosing(frame);
&#160;&#160;frame.getContentPane().add(panel);
&#160;&#160;frame.setSize(width, height);
&#160;&#160;frame.setVisible(true);
}
} ///:~

Comme c'est un outil que vous pouvez utiliser vous-mêmes, il est placé dans la bibliothèque com.bruceeckel.swing. La classe Console contient uniquement des méthodes static. La première est utilisée pour extraire le nom de la classe (en utilisant RTTI) depuis n'importe quel objet, et pour enlever le mot « class », qui est ajouté normalement au début du nom par getClass(). On utilise les méthodes de String : indexOf() pour déterminer si le mot « class » est présent, et substring() pour générer la nouvelle chaîne sans « class » ou le blanc de fin. Ce nom est utilisé pour étiqueter la fenêtre qui est affichée par les méthodes run().

setupClosing() est utilisé pour cacher le code qui provoque la sortie du programme lorsque la JFrame est fermée. Le comportement par défaut est de ne rien faire, donc si on n'appelle pas setupClosing() ou un code équivalent pour le JFrame, l'application ne se ferme pas. Une des raisons pour lesquelles ce code est caché plutôt que d'être placé directement dans les méthodes run() est que cela nous permet d'utiliser la méthode en elle-même lorsque ce qu'on veut faire est plus complexe que ce que fournit run(). Mais il isole aussi un facteur de changement : Java 2 possède deux manières de provoquer la fermeture de certains types de fenêtres. En JDK 1.2, la solution est de créer une nouvelle classe WindowAdapter et d'implémenter windowClosing(), comme vu plus haut (la signification de ceci sera expliquée en détail plus tard dans ce chapitre). Cependant lors de la création du JDK 1.3, les concepteurs de la bibliothèque ont observé qu'on a normalement besoin de fermer des fenêtres chaque fois qu'on crée un programme qui n'est pas une applet, et ils ont ajouté setDefaultCloseOperation() à JFrame et JDialog. Du point de vue de l'écriture du code, la nouvelle méthode est plus agréable à utiliser, mais ce livre a été écrit alors qu'il n'y avait pas de JDK 1.3 implémenté sur Linux et d'autres plateformes, et donc dans l'intérêt de la portabilité toutes versions, la modification a été isolée dans setupClosing().

La méthode run() est surchargée pour fonctionner avec les JApplets, les JPanels, et les JFrames. Remarquez que init() et start() ne sont appelées que s'il s'agit d'une JApplet.

Maintenant toute applet peut être lancée de la console en créant un main() contenant une ligne comme celle-ci :

 
Sélectionnez
Console.run(new MyClass(), 500, 300);

dans laquelle les deux derniers arguments sont la largeur et la hauteur de l'affichage. Voici Applet1c.java modifié pour utiliser Console :

 
Sélectionnez
//: c13:Applet1d.java
// Console exécute des applets depuis la ligne de commande.
// <applet code=Applet1d width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Applet1d extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;getContentPane().add(new JLabel("Applet!"));
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Applet1d(), 100, 50);
}
} ///:~

Ceci permet l'élimination de code répétitif tout en fournissant la plus grande flexibilité pour lancer les exemples.

XV-B-2. Utilisation de l'Explorateur Windows

Si vous utilisez Windows, vous pouvez simplifier le lancement d'un programme Java en ligne de commande en configurant l'explorateur Windows (le navigateur de fichiers de Windows, pas Internet Explorer) de façon à pouvoir double-cliquer sur un fichier .class pour l'exécuter. Il y a plusieurs étapes à effectuer.

D'abord, téléchargez et installez le langage de programmation Perl depuis www.Perl.org. Vous trouverez sur ce site les instructions et la documentation sur ce langage.

Ensuite, créez le script suivant sans la première et la dernière ligne (ce script fait partie du package de sources de ce livre) :

 
Sélectionnez
//:! c13:RunJava.bat
@rem = '--*-Perl-*--
@echo off
perl -x -S "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9
goto endofperl
@rem ';
#!perl
$file = $ARGV[0];
$file =~ s/(.*)\..*/\1/;
$file =~ s/(.*\\)*(.*)/$+/;
&#180;java $file&#180;;
__END__
:endofperl
///:~

Maintenant, ouvrez l'explorateur Windows, sélectionnez Affichage, Options des dossiers, et cliquez sur l'onglet "Types de fichiers". Cliquez sur le bouton "Nouveau type...". Comme "Description du type", entrez "fichier classe Java". Comme "Extension associée", entrez class. Sous "Actions", cliquez sur le bouton "Nouveau...". Comme "Action" entrez "open", et pour "Application utilisée pour effectuer l'action" entrez une ligne telle que celle-ci :

 
Sélectionnez
"c:\aaa\Perl\RunJava.bat" "%L"

en personnalisant le chemin devant RunJava.bat en fonction de l'endroit où vous avez placé le fichier batch.

Une fois cette installation effectuée, vous pouvez exécuter tout programme Java simplement en double-cliquant sur le fichier .class qui contient un main().

XV-C. Création d'un bouton

La création d'un bouton est assez simple : il suffit d'appeler le constructeur JButton avec le label désiré sur le bouton. On verra plus tard qu'on peut faire des choses encore plus jolies, comme y mettre des images graphiques.

En général on créera une variable pour le bouton dans la classe courante, afin de pouvoir s'y référer plus tard.

Le JButton est un composant possédant sa propre petite fenêtre qui sera automatiquement repeinte lors d'une mise à jour. Ceci signifie qu'on ne peint pas explicitement un bouton ni d'ailleurs les autres types de contrôles ; on les place simplement sur le formulaire et on les laisse se repeindre automatiquement. Le placement d'un bouton sur un formulaire se fait dans init() :

 
Sélectionnez
//: c13:Button1.java
// Placement de boutons sur une applet.
// <applet code=Button1 width=200 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Button1 extends JApplet {
JButton 
b1 = new JButton("Button 1"), 
b2 = new JButton("Button 2");
&#160;&#160;public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
}
&#160;&#160;public static void main(String[] args) {
Console.run(new Button1(), 200, 50);
}
} ///:~

On a ajouté ici quelque chose de nouveau : avant d'ajouter un quelconque élément sur la "surface de contenu"[content pane], on lui attribue un nouveau gestionnaire de disposition [layout manager], de type FlowLayout. Le layout manager définit la façon dont la surface décide implicitement de l'emplacement du contrôle dans le formulaire. Le comportement d'une applet est d'utiliser le BorderLayout, mais cela ne marchera pas ici, car (comme on l'apprendra plus tard dans ce chapitre lorsqu'on verra avec plus de détails le contrôle de l'organisation d'un formulaire) son comportement par défaut est de couvrir entièrement chaque contrôle par tout nouveau contrôle ajouté. Cependant, FlowLayout provoque l'alignement des contrôles uniformément dans le formulaire, de gauche à droite et de haut en bas.

XV-D. Capture d'un événement

Vous remarquerez que si vous compilez et exécutez l'applet ci-dessus, rien ne se passe lorsqu'on appuie sur le bouton. C'est à vous de jouer et d'écrire le code qui définira ce qui va se passer. La base de la programmation par événements, qui est très importante dans les interfaces utilisateurs graphiques, est de lier les événements au code qui répond à ces événements.

Ceci est effectué dans Swing par une séparation claire de l'interface (les composants graphiques) et l'implémentation (le code que vous voulez exécuter quand un événement arrive sur un composant). Chaque composant Swing peut répercuter tous les événements qui peuvent lui arriver, et il peut répercuter chaque type d'événement individuellement. Donc si par exemple on n'est pas intéressé par le fait que la souris est déplacée par-dessus le bouton, on n'enregistre pas son intérêt pour cet événement. C'est une façon très directe et élégante de gérer la programmation par événements, et une fois qu'on a compris les concepts de base on peut facilement utiliser les composants Swing qu'on n'a jamais vus auparavant. En fait, ce modèle s'étend à tout ce qui peut être classé comme un JavaBean (que nous verrons plus tard dans ce chapitre).

Au début, on s'intéressera uniquement à l'événement le plus important pour les composants utilisés. Dans le cas d'un JButton, l'événement intéressant est le fait qu'on appuie sur le bouton. Pour enregistrer son intérêt à l'appui sur un bouton, on appelle la méthode addActionListener() de JButton. Cette méthode attend un argument qui est un objet qui implémente l'interface ActionListener, qui contient une seule méthode appelée actionPerformed(). Donc tout ce qu'il faut faire pour attacher du code à un JButton est d'implémenter l'interface ActionListener dans une classe et d'enregistrer un objet de cette classe avec le JButton à l'aide de addActionListener(). La méthode sera appelée lorsque le bouton sera enfoncé (ceci est en général appelé un callback).

Mais que doit être le résultat de l'appui sur ce bouton ? On aimerait voir quelque chose changer à l'écran ; pour cela on va introduire un nouveau composant Swing : le JTextField. C'est un endroit où du texte peut être tapé, ou dans notre cas modifié par le programme. Bien qu'il y ait plusieurs façons de créer un JTextField, la plus simple est d'indiquer au constructeur uniquement quelle largeur on désire pour ce champ. Une fois le JTextField placé sur le formulaire, on peut modifier son contenu en utilisant la méthode setText() (il y a beaucoup d'autres méthodes dans JTextField, que vous pouvez découvrir dans la documentation HTML pour le JDK depuis java.sun.com). Voilà à quoi ça ressemble :

 
Sélectionnez
//: c13:Button2.java
// Réponse aux appuis sur un bouton.
// <applet code=Button2 width=200 height=75>
// </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Button2 extends JApplet {
JButton 
&#160;&#160;b1 = new JButton("Button 1"), 
&#160;&#160;b2 = new JButton("Button 2");
JTextField txt = new JTextField(10);
&#160;&#160;class BL implements ActionListener {
&#160;&#160; public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;String name = 
&#160;&#160;&#160;&#160;&#160;&#160;((JButton)e.getSource()).getText();
&#160;&#160;&#160;&#160;txt.setText(name);
&#160;&#160;}
}
BL al = new BL();
&#160;&#160;public void init() {
&#160;&#160;b1.addActionListener(al);
&#160;&#160;b2.addActionListener(al);
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;cp.add(b1);
&#160;&#160;cp.add(b2);
&#160;&#160;cp.add(txt);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Button2(), 200, 75);
}
} ///:~

Dans init(), addActionListener() est utilisée pour enregistrer l'objet BL pour chacun des boutons.

Il est souvent plus pratique de coder l'ActionListener comme une classe anonyme interne [anonymous inner class], particulièrement lorsqu'on a tendance à n'utiliser qu'une seule instance de chaque classe listener. Button2.java peut être modifié de la façon suivante pour utiliser une classe interne anonyme :

 
Sélectionnez
//: c13:Button2b.java
// Utilisation de classes anonymes internes.
// <applet code=Button2b width=200 height=75>
// </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Button2b extends JApplet {
JButton 
&#160;&#160;b1 = new JButton("Button 1"), 
&#160;&#160;b2 = new JButton("Button 2");
JTextField txt = new JTextField(10);
ActionListener al = new ActionListener() {
&#160;&#160; public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;String name = 
&#160;&#160;&#160;&#160;&#160;&#160;((JButton)e.getSource()).getText();
&#160;&#160;&#160;&#160;txt.setText(name);
&#160;&#160;}
};
&#160;&#160;public void init() {
&#160;&#160;b1.addActionListener(al);
&#160;&#160;b2.addActionListener(al);
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;cp.add(b1);
&#160;&#160;cp.add(b2);
&#160;&#160;cp.add(txt);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Button2b(), 200, 75);
}
} ///:~

L'utilisation d'une classe anonyme interne sera préférée (si possible) pour les exemples de ce livre.

XV-E. Zones de texte

Un JTextArea est comme un JTextField, sauf qu'il peut avoir plusieurs lignes et possède plus de fonctionnalités. Une méthode particulièrement utile est append() ; avec cette méthode on peut facilement transférer une sortie dans un JTextArea, faisant de ce fait d'un programme Swing une amélioration (du fait qu'on peut scroller en arrière) par rapport à ce qui a été fait jusqu'ici en utilisant des programmes de ligne de commande qui impriment sur la sortie standard. Comme exemple, le programme suivant remplit un JTextArea avec la sortie du générateur geography du titre XI :

 
Sélectionnez
//: c13:TextArea.java
// Utilisation du contrôle JTextArea.
// <applet code=TextArea width=475 height=425>
// </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;
import com.bruceeckel.swing.*;
import com.bruceeckel.util.*;

public class TextArea extends JApplet {
JButton 
&#160;&#160;b = new JButton("Add Data"),
&#160;&#160;c = new JButton("Clear Data");
JTextArea t = new JTextArea(20, 40);
Map m = new HashMap();
&#160;&#160;public void init() {
&#160;&#160; // Utilisation de toutes les données :
&#160;&#160;Collections2.fill(m, 
&#160;&#160;&#160;&#160;Collections2.geography, 
&#160;&#160;&#160;&#160;CountryCapitals.pairs.length);
&#160;&#160;b.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;for(Iterator it= m.entrySet().iterator();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;it.hasNext();){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Map.Entry me = (Map.Entry)(it.next());
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.append(me.getKey() + ": " 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;+ me.getValue() + "\n");
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;});
&#160;&#160;c.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;t.setText("");
&#160;&#160;&#160;&#160;}
&#160;&#160;});
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.setLayonew FlowLayout());
&#160;&#160;cp.add(new JScrollPane(t));
&#160;&#160;cp.add(b);
&#160;&#160;cp.add(c);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new TextArea(), 475, 425);
}
} ///:~

Dans init(), le Map est rempli avec tous les pays et leurs capitales. Remarquons que pour chaque bouton l'ActionListener est créé et ajouté sans définir de variable intermédiaire, puisqu'on n'aura plus jamais besoin de s'y référer dans la suite du programme. Le bouton "Add Data" formate et ajoute à la fin toutes les données, tandis que le bouton "Clear Data" utilise setText() pour supprimer tout le texte du JTextArea.

Lors de l'ajout du JTextArea à l'applet, il est enveloppé dans un JScrollPane, pour contrôler le scrolling quand trop de texte est placé à l'écran. C'est tout ce qu'il y a à faire pour fournir des fonctionnalités de scrolling complètes. Ayant essayé d'imaginer comment faire l'équivalent dans d'autres environnements de programmation de GUI, je suis très impressionné par la simplicité et la bonne conception de composants tels que le JScrollPane.

XV-F. Contrôle de la disposition

La façon dont on place les composants sur un formulaire en Java est probablement différente de tout système de GUI que vous avez utilisé. Premièrement, tout est dans le code ; il n'y a pas de ressources qui contrôlent le placement des composants. Deuxièmement, la façon dont les composants sont placés dans un formulaire est contrôlée non pas par un positionnement absolu, mais par un layout manager qui décide comment les composants sont placés, selon l'ordre dans lequel on les ajoute ( add() ). La taille, la forme et le placement des composants seront notablement différents d'un layout manager à l'autre. De plus, les gestionnaires de disposition s'adaptent aux dimensions de l'applet ou de la fenêtre de l'application, de sorte que si la dimension de la fenêtre est changée, la taille, la forme et le placement des composants sont modifiés en conséquence.

JApplet, JFrame, JWindow et JDialog peuvent chacun fournir un Container avec getContentPane() qui peut contenir et afficher des Components. Dans Container, il y a une méthode appelée setLayout() qui permet de choisir le layout manager. D'autres classes telles que JPanel contiennent et affichent des composants directement, et donc il faut leur imposer directement le layout manager, sans utiliser le content pane.

Dans cette section nous allons explorer les divers gestionnaires de disposition en créant des boutons (puisque c'est ce qu'il y a de plus simple). Il n'y aura aucune capture d'événements de boutons puisque ces exemples ont pour seul but de montrer comment les boutons sont disposés.

XV-F-1. BorderLayout

L'applet utilise un layout manager par défaut : le BorderLayout (certains des exemples précédents ont modifié le layout manager par défaut pour FlowLayout). Sans autre information, il prend tout ce qu'on lui ajoute ( add() ) et le place au centre, en étirant l'objet dans toutes les directions jusqu'aux bords.

Cependant le BorderLayout ne se résume pas qu'à cela. Ce layout manager possède le concept d'une zone centrale et de quatre régions périphériques. Quand on ajoute quelque chose à un panel qui utilise un BorderLayout, on peut utiliser la méthode add() surchargée qui prend une valeur constante comme premier argument. Cette valeur peut être une des suivantes :

BorderLayout.NORTH (en haut) BorderLayout.SOUTH (en bas) BorderLayout.EAST (à droite) BorderLayout.WEST (à gauche) BorderLayout.CENTER (remplir le milieu, jusqu'aux autres composants ou jusqu'aux bords)

Si aucune région n'est spécifiée pour placer l'objet, le défaut est CENTER.

Voici un exemple simple. Le layout par défaut est utilisé, puisque JApplet a BorderLayout par défaut :

 
Sélectionnez
//: c13:BorderLayout1.java
// Démonstration de BorderLayout.
// <applet code=BorderLayout1 
// width=300 height=250> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class BorderLayout1 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.add(BorderLayout.NORTH, 
&#160;&#160;&#160;&#160;new JButton("North"));
&#160;&#160;cp.add(BorderLayout.SOUTH, 
&#160;&#160;&#160;&#160;new JButton("South"));
&#160;&#160;cp.add(BorderLayout.EAST, 
&#160;&#160;&#160;&#160;new JButton("East"));
&#160;&#160;cp.add(BorderLayout.WEST, 
&#160;&#160;&#160;&#160;new JButton("West"));
cp.add(BorderLayout.CENTER, 
&#160;&#160;&#160;&#160;new JButton("Center"));
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new BorderLayout1(), 300, 250);
}
} ///:~

Pour chaque placement autre que CENTER, l'élément qu'on ajoute est comprimé pour tenir dans le plus petit espace le long d'une dimension et étiré au maximum le long de l'autre dimension. CENTER, par contre, s'étend dans chaque dimension pour occuper le milieu.

XV-F-2. FlowLayout

Celui-ci aligne simplement les composants sur le formulaire, de gauche à droite jusqu'à ce que l'espace du haut soit rempli, puis descend d'une rangée et continue l'alignement.

Voici un exemple qui positionne le layout manager en FlowLayout et place ensuite des boutons sur le formulaire. On remarquera qu'avec FlowLayout les composants prennent leur taille naturelle. Un JButton, par exemple, aura la taille de sa chaîne.

 
Sélectionnez
//: c13:FlowLayout1.java
// Démonstration de FlowLayout.
// <applet code=FlowLayout1 
// width=300 height=250> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class FlowLayout1 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;cp.add(new JButton("Button " + i));
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new FlowLayout1(), 300, 250);
}
} ///:~

Tous les composants sont compactés à leur taille minimum dans un FlowLayout, ce qui fait qu'on peut parfois obtenir un comportement surprenant. Par exemple, vu qu'un JLabel prend la taille de sa chaîne, une tentative de justifier à droite son texte ne donne pas de modification de l'affichage dans un FlowLayout.

XV-F-3. GridLayout

Un GridLayout permet de construire un tableau de composants, et lorsqu'on les ajoute ils sont placés de gauche à droite et de haut en bas dans la grille. Dans le constructeur on spécifie le nombre de rangées et de colonnes nécessaires, et celles-ci sont disposées en proportions identiques.

 
Sélectionnez
//: c13:GridLayout1.java
// Démonstration de GridLayout.
// <applet code=GridLayout1 
// width=300 height=250> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class GridLayout1 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.setLayout(new GridLayout(7,3));
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;cp.add(new JButton("Button " + i));
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new GridLayout1(), 300, 250);
}
} ///:~

Dans ce cas il y a 21 cases, mais seulement 20 boutons. La dernière case est laissée vide, car il n'y a pas d'équilibrage dans un GridLayout.

XV-F-4. GridBagLayout

Le GridBagLayout nous donne un contrôle fin pour décider exactement comment les régions d'une fenêtre vont se positionner et se replacer lorsque la fenêtre est redimensionnée. Cependant, c'est aussi le plus compliqué des layout managers, et il est assez difficile à comprendre. Il est destiné principalement à la génération de code automatique par un constructeur d'interfaces utilisateurs graphiques [GUI builder] (les bons GUI builders utilisent GridBagLayout plutôt que le placement absolu). Si votre modèle est compliqué au point que vous sentiez le besoin d'utiliser le GridBagLayout, vous devrez dans ce cas utiliser un outil GUI builder pour générer ce modèle. Si vous pensez devoir en connaître les détails internes, je vous renvoie à Core Java 2 par Horstmann & Cornell (Prentice-Hall, 1999), ou un livre dédié à Swing, comme point de départ.

XV-F-5. Positionnement absolu

Il est également possible de forcer la position absolue des composants graphiques de la façon suivante :

  1. Positionner un layout manager null pour le Container : setLayout(null) ;
  2. Appeler setBounds() ou reshape() (selon la version du langage) pour chaque composant, en passant un rectangle de limites avec ses coordonnées en pixels. Ceci peut se faire dans le constructeur, ou dans paint(), selon le but désiré.

Certains GUI builders utilisent cette approche de manière extensive, mais ce n'est en général pas la meilleure manière de générer du code. Les GUI builders les plus efficaces utilisent plutôt GridBagLayout.

XV-F-6. BoxLayout

Les gens ayant tellement de problèmes pour comprendre et utiliser GridBagLayout, Swing contient également le BoxLayout, qui offre la plupart des avantages du GridBagLayout sans en avoir la complexité, de sorte qu'on peut souvent l'utiliser lorsqu'on doit coder à la main des layouts (encore une fois, si votre modèle devient trop compliqué, utilisez un GUI builder qui générera les GridBagLayouts à votre place). BoxLayout permet le contrôle du placement des composants soit verticalement soit horizontalement, et le contrôle de l'espace entre les composants en utilisant des choses appelées struts (entretoises) et glue (colle). D'abord, voyons comment utiliser BoxLayout directement, en faisant le même genre de démonstration que pour les autres layout managers :

 
Sélectionnez
//: c13:BoxLayout1.java
// BoxLayouts vertical et horizontal.
// <applet code=BoxLayout1 
// width=450 height=200> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class BoxLayout1 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;JPanel jpv = new JPanel();
&#160;&#160;jpv.setLayout(
&#160;&#160;&#160;&#160;new BoxLayout(jpv, BoxLayout.Y_AXIS));
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;jpv.add(new JButton("" + i));
&#160;&#160;JPanel jph = new JPanel();
&#160;&#160;jph.setLayout(
&#160;&#160;&#160;&#160;new BoxLayout(jph, BoxLayout.X_AXIS));
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;jph.add(new JButton("" + i));
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.add(BorderLayout.EAST, jpv);
&#160;&#160;cp.add(BorderLayout.SOUTH, jph);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new BoxLayout1(), 450, 200);
}
} ///:~

Le constructeur du BoxLayout est un peu différent des autres layout managers : on fournit le Container que le BoxLayout doit contrôler comme premier argument, et la direction du layout comme deuxième argument.

Pour simplifier les choses, il y a un container spécial appelé Box qui utilise BoxLayout comme manager d'origine. L'exemple suivant place les composants horizontalement et verticalement en utilisant Box, qui possède deux méthodes static pour créer des boxes avec des alignements verticaux et horizontaux :

 
Sélectionnez
//: c13:Box1.java
// BoxLayouts vertical et horizontal.
// <applet code=Box1 
// width=450 height=200> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Box1 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Box bv = Box.createVerticalBox();
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;bv.add(new JButton("" + i));
&#160;&#160;Box bh = Box.createHorizontalBox();
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;bh.add(new JButton("" + i));
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.add(BorderLayout.EAST, bv);
&#160;&#160;cp.add(BorderLayout.SOUTH, bh);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Box1(), 450, 200);
}
} ///:~

Une fois qu'on a obtenu un Box, on le passe en second argument quand on ajoute des composants au content pane.

Les struts ajoutent de l'espace entre les composants, mesuré en pixels. Pour utiliser un strut, on l'ajoute simplement entre les ajouts de composants que l'on veut séparer :

 
Sélectionnez
//: c13:Box2.java
// Ajout de struts.
// <applet code=Box2 
// width=450 height=300> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Box2 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Box bv = Box.createVerticalBox();
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;bv.add(new JButton("" + i));
&#160;&#160;&#160;&#160;bv.add(Box.createVerticalStrut(i*10));
&#160;&#160;}
&#160;&#160;Box bh = Box.createHorizontalBox();
&#160;&#160; for(int i = 0; i &#160;&#160;&#160;&#160;bh.add(new JButton("" + i));
&#160;&#160;&#160;&#160;bh.add(Box.createHorizontalStrut(i*10));
&#160;&#160;}
&#160;&#160;Container cp = getContentPane();
&#160;&#160;cp.add(BorderLayout.EAST, bv);
&#160;&#160;cp.add(BorderLayout.SOUTH, bh);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Box2(), 450, 300);
}
} ///:~

//: c13:Box3.java
// Utilisation de Glue.
// <applet code=Box3 
// width=450 height=300> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Box3 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Box bv = Box.createVerticalBox();
&#160;&#160;bv.add(new JLabel("Hello"));
&#160;&#160;bv.add(Box.createVerticalGlue());
&#160;&#160;bv.add(new JLabel("Applet"));
&#160;&#160;bv.add(Box.createVerticalGlue());
&#160;&#160;bv.add(new JLabel("World"));
&#160;&#160;Box bh = Box.createHorizontalBox();
&#160;&#160;bh.add(new JLabel("Hello"));
&#160;&#160;bh.add(Box.createHorizontalGlue());
&#160;&#160;bh.add(new JLabel("Applet"));
&#160;&#160;bh.add(Box.createHorizontalGlue());
&#160;&#160;bh.add(new JLabel("World"));
&#160;&#160;bv.add(Box.createVerticalGlue());
&#160;&#160;bv.add(bh);
&#160;&#160;bv.add(Box.createVerticalGlue());
&#160;&#160;getContentPane().add(bv);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Box3(), 450, 300);
}
} ///:~

Un strut fonctionne dans une direction, mais une rigid area (surface rigide) fixe l'espace entre les composants dans chaque direction :

 
Sélectionnez
//: c13:Box4.java
// Des Rigid Areas sont comme des paires de struts.
// <applet code=Box4 
// width=450 height=300> </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class Box4 extends JApplet {
&#160;&#160;public void init() {
&#160;&#160;Box bv = Box.createVerticalBox();
&#160;&#160;bv.add(new JButton("Top"));
&#160;&#160;bv.add(Box.createRigidArea(
&#160;&#160;&#160;&#160;new Dimension(120, 90)));
&#160;&#160;bv.add(new JButton("Bottom"));
&#160;&#160;Box bh = Box.createHorizontalBox();
&#160;&#160;bh.add(new JButton("Left"));
&#160;&#160;bh.add(Box.createRigidArea(
&#160;&#160;&#160;&#160;new Dimension(160, 80)));
&#160;&#160;bh.add(new JButton("Right"));
&#160;&#160;bv.add(bh);
&#160;&#160;getContentPane().add(bv);
}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;Console.run(new Box4(), 450, 300);
}
} ///:~

Il faut savoir que les rigid areas sont un peu controversées. Comme elles utilisent des valeurs absolues, certaines personnes pensent qu'elles causent plus de problèmes qu'elles n'en résolvent.

XV-F-7. La meilleure approche ?

Swing est puissant ; il peut faire beaucoup de choses en quelques lignes de code. Les exemples de ce livre sont raisonnablement simples, et dans un but d'apprentissage il est normal de les écrire à la main. On peut en fait réaliser pas mal de choses en combinant des layouts simples. À un moment donné, il devient cependant déraisonnable de coder à la main des formulaires de GUI. Cela devient trop compliqué et ce n'est pas une bonne manière d'utiliser son temps de programmation. Les concepteurs de Java et de Swing ont orienté le langage et ses bibliothèques de manière à soutenir des outils de construction de GUI, qui ont été créés dans le but de rendre la tâche de programmation plus facile. À partir du moment où on comprend ce qui se passe dans les layouts et comment traiter les événements (décrits plus loin), il n'est pas particulièrement important de connaître effectivement tous les détails sur la façon de positionner les composants à la main. Laissons les outils appropriés le faire pour nous (Java est après tout conçu pour augmenter la productivité du programmeur).

XV-G. Le modèle d'événements de Swing

Dans le modèle d'événements de Swing, un composant peut initier (envoyer [fire]) un événement. Chaque type d'événement est représenté par une classe distincte. Lorsqu'un événement est envoyé, il est reçu par un ou plusieurs écouteurs [listeners], qui réagissent à cet événement. De ce fait, la source d'un événement et l'endroit où cet événement est traité peuvent être séparés. Puisqu'on utilise en général les composants Swing tels quels, mais qu'il faut écrire du code appelé lorsque les composants reçoivent un événement, ceci est un excellent exemple de la séparation de l'interface et de l'implémentation.

Chaque écouteur d'événements [event listener] est un objet d'une classe qui implémente une interface particulière de type listener. En tant que programmeur, il faut créer un objet listener et l'enregistrer avec le composant qui envoie l'événement. Cet enregistrement se fait par appel à une méthode addXXXListener() du composant envoyant l'événement, dans lequel XXX représente le type d'événement qu'on écoute. On peut facilement savoir quels types d'événements peuvent être gérés en notant les noms des méthodes addListener, et si on essaie d'écouter des événements erronés, l'erreur sera signalée à la compilation. On verra plus loin dans ce chapitre que les JavaBeans utilisent aussi les noms des méthodes addListener pour déterminer quels événements un Bean peut gérer.

Toute notre logique des événements va se trouver dans une classe listener. Lorsqu'on crée une classe listener, la seule restriction est qu'elle doit implémenter l'interface appropriée. On peut créer une classe listener globale, mais on est ici dans un cas où les classes internes sont assez utiles, non seulement parce qu'elles fournissent un groupement logique de nos classes listener à l'intérieur des classes d'interface utilisateur ou de logique métier qu'elles desservent, mais aussi (comme on le verra plus tard) parce que le fait qu'un objet d'une classe interne garde une référence à son objet parent fournit une façon élégante d'appeler à travers les frontières des classes et des sous-systèmes.

Jusqu'ici, tous les exemples de ce chapitre ont utilisé le modèle d'événements Swing, mais le reste de cette section va préciser les détails de ce modèle.

XV-G-1. Événements et types de listeners

Chaque composant Swing contient des méthodes addXXXListener() et removeXXXListener() de manière à ce que les types de listeners adéquats puissent être ajoutés et enlevés de chaque composant. On remarquera que le XXX dans chaque cas représente également l'argument de cette méthode, par exemple : addMyListener(MyListener m). Le tableau suivant contient les événements, listeners et méthodes de base associées aux composants de base qui supportent ces événements particuliers en fournissant les méthodes addXXXListener() et removeXXXListener(). Il faut garder en tête que le modèle d'événements est destiné à être extensible, et donc on pourra rencontrer d'autres types d'événements et de listeners non couverts par ce tableau.

Événement, interface listener et méthodes add et remove Composants supportant cet événement
ActionEvent ActionListener addActionListener() removeActionListener() JButton, JList, JTextField, JMenuItem et ses dérivés, comprenant JCheckBoxMenuItem, JMenu, et JpopupMenu.
AdjustmentEvent AdjustmentListener addAdjustmentListener() removeAdjustmentListener() JScrollbar et tout ce qu'on crée qui implémente l'interface Adjustable.
ComponentEvent ComponentListener addComponentListener() removeComponentListener() *Component et ses dérivés, comprenant JButton, JCanvas, JCheckBox, JComboBox, Container, JPanel, JApplet, JScrollPane, Window, JDialog, JFileDialog, JFrame, JLabel, JList, JScrollbar, JTextArea, et JTextField.
ContainerEvent ContainerListener addContainerListener() removeContainerListener() Container et ses dérivés, comprenant JPanel, JApplet, JScrollPane, Window, JDialog, JFileDialog, et JFrame.
FocusEvent FocusListener addFocusListener() removeFocusListener() Component et dérivés*.
KeyEvent KeyListener addKeyListener() removeKeyListener() Component et dérivés*.
MouseEvent (à la fois pour les clics et pour le déplacement) MouseListener addMouseListener() removeMouseListener() Component et dérivés*.
MouseEvent (55)(à la fois pour les clics et pour le déplacement) MouseMotionListener addMouseMotionListener() removeMouseMotionListener() Component et dérivés*.
WindowEvent WindowListener addWindowListener() removeWindowListener() Window et ses dérivés, comprenant JDialog, JFileDialog, and JFrame.
ItemEvent ItemListener addItemListener() removeItemListener() JCheckBox, JCheckBoxMenuItem, JComboBox, JList, et tout ce qui implémente l'interface ItemSelectable.
TextEvent TextListener addTextListener() removeTextListener() Tout ce qui est dérivé de JTextComponent, comprenant JTextArea et JTextField.

On voit que chaque type de composant ne supporte que certains types d'événements. Il semble assez difficile de rechercher tous les événements supportés par chaque composant. Une approche plus simple consiste à modifier le programme ShowMethodsClean.java du titre XIV de manière à ce qu'il affiche tous les event listeners supportés par tout composant Swing entré.

Le Titre XIV a introduit la réflexion et a utilisé cette fonctionnalité pour rechercher les méthodes d'une classe donnée, soit une liste complète des méthodes, soit un sous-ensemble des méthodes dont le nom contient un mot-clef donné. La magie dans ceci est qu'il peut automatiquement nous montrer toutes les méthodes d'une classe sans qu'on soit obligé de parcourir la hiérarchie des héritages en examinant les classes de base à chaque niveau. De ce fait, il fournit un outil précieux permettant de gagner du temps pour la programmation : comme les noms de la plupart des méthodes Java sont parlants et descriptifs, on peut rechercher les noms de méthodes contenant un mot particulier. Lorsqu'on pense avoir trouvé ce qu'on cherchait, il faut alors vérifier la documentation en ligne.

Comme dans le titre XIV on n'avait pas encore vu Swing, l'outil de ce chapitre était une application de ligne de commande. En voici une version plus pratique avec interface graphique, spécialisée dans la recherche des méthodes addListener dans les composants Swing :

 
Sélectionnez
//: c13:ShowAddListeners.java
// Affiche les méthodes "addXXXListener"
// d'une classe Swing donnée.
// <applet code = ShowAddListeners 
// width=500 height=400></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.*;
import java.io.*;
import com.bruceeckel.swing.*;
import com.bruceeckel.util.*;

public class ShowAddListeners extends JApplet {
&#160;&#160;Class cl;
&#160;&#160;Method[] m;
&#160;&#160;Constructor[] ctor;
&#160;&#160;String[] n = new String[0];
&#160;&#160;JTextField name = new JTextField(25);
&#160;&#160;JTextArea results = new JTextArea(40, 65);
&#160;&#160;class NameL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;String nm = name.getText().trim();
&#160;&#160;&#160;&#160;&#160;&#160;if(nm.length() == 0) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;results.setText("No match");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;n = new String[0];
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;return;
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;try {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;cl = Class.forName("javax.swing." + nm);
&#160;&#160;&#160;&#160;&#160;&#160;} catch(ClassNotFoundException ex) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;results.setText("No match");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;return;
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;m = cl.getMethods();
&#160;&#160;&#160;&#160;&#160;&#160;// Conversion en un tableau de Strings :
&#160;&#160;&#160;&#160;&#160;&#160;n = new String[m.length];
&#160;&#160;&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;n[i] = m[i].toString();
&#160;&#160;&#160;&#160;&#160;&#160;reDisplay();
&#160;&#160;&#160;&#160;}
&#160;&#160;} 
&#160;&#160;void reDisplay() {
&#160;&#160;&#160;&#160;// Creation de l'ensemble des résultats :
&#160;&#160;&#160;&#160;String[] rs = new String[n.length];
&#160;&#160;&#160;&#160;int j = 0;
&#160;&#160;&#160;&#160;for (int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;if(n[i].indexOf("add") != -1 &&
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;n[i].indexOf("Listener") != -1)
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;rs[j++] = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;n[i].substring(n[i].indexOf("add"));
&#160;&#160;&#160;&#160;results.setText("");
&#160;&#160;&#160;&#160;for (int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;results.append(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;StripQualifiers.strip(rs[i]) + "\n");
&#160;&#160;}
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;name.addActionListener(new NameL());
&#160;&#160;&#160;&#160;JPanel top = new JPanel();
&#160;&#160;&#160;&#160;top.add(new JLabel(
&#160;&#160;&#160;&#160;&#160;&#160;"Swing class name (press ENTER):"));
&#160;&#160;&#160;&#160;top.add(name);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(BorderLayout.NORTH, top);
&#160;&#160;&#160;&#160;cp.add(new JScrollPane(results));
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new ShowAddListeners(), 500,400);
&#160;&#160;}
} ///:~

La classe StripQualifiers définie au livre XIV est réutilisée ici en important la bibliothèque com.bruceeckel.util.

L'interface utilisateur graphique contient un JTextField name dans lequel on saisit le nom de la classe Swing à rechercher. Les résultats sont affichés dans une JTextArea.

On remarquera qu'il n'y a pas de boutons ou autres composants pour indiquer qu'on désire lancer la recherche. C'est parce que le JTextField est surveillé par un ActionListener. Lorsqu'on y fait un changement suivi de ENTER, la liste est immédiatement mise à jour. Si le texte n'est pas vide, il est utilisé dans Class.forName() pour rechercher la classe. Si le nom est incorrect, Class.forName() va échouer, c'est-à-dire qu'il va émettre une exception. Celle-ci est interceptée et le JTextArea est positionné à "No match". Mais si on tape un nom correct (les majuscules/minuscules comptent), Class.forName() réussit et getMethods() retourne un tableau d'objets Method. Chacun des objets du tableau est transformé en String à l'aide de toString() (cette méthode fournit la signature complète de la méthode) et ajoutée à n, un tableau de Strings. Le tableau n est un membre de la classe ShowAddListeners et est utilisé pour mettre à jour l'affichage chaque fois que reDisplay() est appelé.

reDisplay() crée un tableau de Strings appelé rs (pour "result set" : ensemble de résultats). L'ensemble des résultats est conditionnellement copié depuis les Strings de n qui contiennent add et Listener. indexOf() et substring() sont ensuite utilisés pour enlever les qualificatifs tels que public, static, etc. Enfin, StripQualifiers.strip() enlève les qualificatifs de noms.

Ce programme est une façon pratique de rechercher les capacités d'un composant Swing. Une fois connus les événements supportés par un composant donné, il n'y a pas besoin de rechercher autre chose pour réagir à cet événement. Il suffit de :

  1. Prendre le nom de la classe événement et retirer le mot Event. Ajouter le mot Listener à ce qui reste. Ceci donne le nom de l'interface listener qu'on doit implémenter dans une classe interne ;
  2. Implémenter l'interface ci-dessus et écrire les méthodes pour les événements qu'on veut intercepter. Par exemple, on peut rechercher les événements de déplacement de la souris, et on écrit donc le code pour la méthode mouseMoved() de l'interface MouseMotionListener (il faut également implémenter les autres méthodes, bien sûr, mais il y a souvent un raccourci que nous verrons bientôt) ;
  3. Créer un objet de la classe listener de l'étape 2. L'enregistrer avec le composant avec la méthode dont le nom est fourni en ajoutant add au début du nom du listener. Par exemple, addMouseMotionListener().

Voici quelques-unes des interfaces listeners :

Ce n'est pas une liste exhaustive, en partie du fait que le modèle d'événements nous permet de créer nos propres types d'événements et listeners associés. De ce fait, on rencontrera souvent des bibliothèques qui ont inventé leurs propres événements, et la connaissance acquise dans ce chapitre nous permettra de comprendre l'utilisation de ces événements.

XV-G-1-a. Utilisation de listener adapters pour simplifier

Dans le tableau ci-dessus, on peut voir que certaines interfaces listener ne possèdent qu'une seule méthode. Celles-ci sont triviales à implémenter puisqu'on ne les implémentera que lorsqu'on désire écrire cette méthode particulière. Par contre, les interfaces listener qui ont plusieurs méthodes peuvent être moins agréables à utiliser. Par exemple, quelque chose qu'il faut toujours faire en créant une application est de fournir un WindowListener au JFrame de manière à pouvoir appeler System.exit() pour sortir de l'application lorsqu'on reçoit l'événement windowClosing(). Mais comme WindowListener est une interface, il faut implémenter chacune de ses méthodes même si elles ne font rien. Cela peut être ennuyeux.

Pour résoudre le problème, certaines (mais pas toutes) des interfaces listener qui ont plus d'une méthode possèdent des adaptateurs [adapters], dont vous pouvez voir les noms dans le tableau ci-dessus. Chaque adaptateur fournit des méthodes vides par défaut pour chacune des méthodes de l'interface. Ensuite il suffit d'hériter de cet adaptateur et de redéfinir uniquement les méthodes qu'on doit modifier. Par exemple, le WindowListener qu'on utilisera normalement ressemble à ceci (souvenez-vous qu'il a été encapsulé dans la classe Console de com.bruceeckel.swing) :

 
Sélectionnez
class MyWindowListener extends WindowAdapter {
&#160;&#160;public void windowClosing(WindowEvent e) {
System.exit(0);
}
}

Le seul but des adaptateurs est de faciliter la création des classes listener.

Il y a cependant un désavantage lié aux adaptateurs, sous la forme d'un piège. Supposons qu'on écrive un WindowAdapter comme celui ci-dessus :

 
Sélectionnez
class MyWindowListener extends WindowAdapter {
&#160;&#160;public void WindowClosing(WindowEvent e) {
System.exit(0);
}
}

Ceci ne marche pas, mais il nous rendra fous à comprendre pourquoi, car tout va compiler et s'exécuter correctement, sauf que la fermeture de la fenêtre ne fera pas sortir du programme. Voyez-vous le problème ? Il est situé dans le nom de la méthode : WindowClosing() au lieu de windowClosing(). Une simple erreur de majuscule se traduit par l'ajout d'une méthode nouvelle. Ce n'est cependant pas cette méthode qui est appelée lorsque la fenêtre est fermée, de sorte qu'on n'obtient pas le résultat attendu. En dépit de cet inconvénient, une interface garantit que les méthodes sont correctement implémentées.

XV-G-2. Surveiller plusieurs événements

Pour nous prouver que ces événements sont bien déclenchés, et en tant qu'expérience intéressante, créons une applet qui surveille les autres comportements d'un JButton, autres que le simple fait qu'il soit appuyé ou pas. Cet exemple montre également comment hériter de notre propre objet bouton, car c'est ce qui est utilisé comme cible de tous les événements intéressants. Pour cela, il suffit d'hériter de JButton name="fnB69" href="#fn69" (56).

La classe MyButton est une classe interne de TrackEvent, de sorte que MyButton peut aller dans la fenêtre parent et manipuler ses champs textes, ce qu'il faut pour pouvoir écrire une information d'état dans les champs du parent. Bien sûr ceci est une solution limitée, puisque MyButton peut être utilisée uniquement avec TrackEvent. Ce genre de code est parfois appelé "fortement couplé" :

 
Sélectionnez
//: c13:TrackEvent.java
// Montre les événements lorsqu'ils arrivent.
// <applet code=TrackEvent
//&#160;&#160;width=700 height=500></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;

public class TrackEvent extends JApplet {
HashMap h = new HashMap();
String[] event = {
&#160;&#160; "focusGained", "focusLost", "keyPressed",
&#160;&#160; "keyReleased", "keyTyped", "mouseClicked",
&#160;&#160; "mouseEntered", "mouseExited","mousePressed",
&#160;&#160; "mouseReleased", "mouseDragged", "mouseMoved"
};
MyButton
b1 = new MyButton(Color.blue, "test1"),
b2 = new MyButton(Color.red, "test2");
&#160;&#160;class MyButton extends JButton {
&#160;&#160; void report(String field, String msg) {
((JTextField)h.get(field)).setText(msg);
}&#160;&#160;&#160;&#160;
FocusListener fl = new FocusListener() {
&#160;&#160;&#160;&#160;public void focusGained(FocusEvent e) {
&#160;&#160; report("focusGained", e.paramString());
}
&#160;&#160;&#160;&#160;public void focusLost(FocusEvent e) {
&#160;&#160; report("focusLost", e.paramString());
}
};
KeyListener kl = new KeyListener() {
&#160;&#160;&#160;&#160;public void keyPressed(KeyEvent e) {
&#160;&#160; report("keyPressed", e.paramString());
}
&#160;&#160;&#160;&#160;public void keyReleased(KeyEvent e) {
&#160;&#160; report("keyReleased", e.paramString());
}
&#160;&#160;&#160;&#160;public void keyTyped(KeyEvent e) {
&#160;&#160; report("keyTyped", e.paramString());
}
};
MouseListener ml = new MouseListener() {
&#160;&#160;&#160;&#160;public void mouseClicked(MouseEvent e) {
&#160;&#160; report("mouseClicked", e.paramString());
}
&#160;&#160;&#160;&#160;public void mouseEntered(MouseEvent e) {
&#160;&#160; report("mouseEntered", e.paramString());
}
&#160;&#160;&#160;&#160;public void mouseExited(MouseEvent e) {
&#160;&#160; report("mouseExited", e.paramString());
}
&#160;&#160;&#160;&#160;public void mousePressed(MouseEvent e) {
&#160;&#160; report("mousePressed", e.paramString());
}
&#160;&#160;&#160;&#160;public void mouseReleased(MouseEvent e) {
&#160;&#160; report("mouseReleased", e.paramString());
}
};
MouseMotionListener mml = 
&#160;&#160;&#160;&#160;new MouseMotionListener() {
&#160;&#160;&#160;&#160;public void mouseDragged(MouseEvent e) {
&#160;&#160; report("mouseDragged", e.paramString());
}
&#160;&#160;&#160;&#160;public void mouseMoved(MouseEvent e) {
&#160;&#160; report("mouseMoved", e.paramString());
}
};
&#160;&#160; public MyButton(Color color, String label) {
&#160;&#160;&#160;&#160;super(label);
setBackground(color);
addFocusListener(fl);
addKeyListener(kl);
addMouseListener(ml);
addMouseMotionListener(mml);
}
}&#160;&#160;
&#160;&#160;public void init() {
Container c = getContentPane();
c.setLayout(new GridLayout(event.length+1,2));
&#160;&#160; for(int i = 0; i JTextField t = new JTextField();
t.setEditable(false);
c.add(new JLabel(event[i], JLabel.RIGHT));
c.add(t);
h.put(event[i], t);
}
c.add(b1);
c.add(b2);
}
&#160;&#160;public static void main(String[] args) {
Console.run(new TrackEvent(), 700, 500);
}
} ///:~

Dans le constructeur de MyButton, la couleur des boutons est positionnée par un appel à SetBackground(). Les listeners sont tous installés par de simples appels de méthodes.

La classe TrackEvent contient une HashMap pour contenir les chaînes représentant le type d'événement et les JTextFields dans lesquels l'information sur cet événement est conservée. Bien sûr, ceux-ci auraient pu être créés en statique plutôt qu'en les mettant dans une HashMap, mais je pense que vous serez d'accord que c'est beaucoup plus facile à utiliser et modifier. En particulier, si on a besoin d'ajouter ou supprimer un nouveau type d'événement dans TrackEvent, il suffit d'ajouter ou supprimer une chaîne dans le tableau event, et tout le reste est automatique.

Lorsque report() est appelé, on lui donne le nom de l'événement et la chaîne des paramètres de cet événement. Il utilise le HashMap h de la classe externe pour rechercher le JTextField associé à l'événement portant ce nom, et place alors la chaîne des paramètres dans ce champ.

Cet exemple est amusant à utiliser, car on peut réellement voir ce qui se passe avec les événements dans son programme.

XV-H. Un catalogue de composants Swing

Maintenant que nous connaissons les layout managers et le modèle d'événements, nous sommes prêts pour voir comment utiliser les composants Swing. Cette section est une visite non exhaustive des composants Swing et des fonctionnalités que vous utiliserez probablement la plupart du temps. Chaque exemple est conçu pour être de taille raisonnable de manière à pouvoir facilement récupérer le code dans d'autres programmes.

Vos pouvez facilement voir à quoi ressemble chacun de ces exemples en fonctionnement, en visualisant les pages HTML dans le code source téléchargeable de ce chapitre.

Gardez en tête :

  1. La documentation HTML de java.sun.com comprend toutes les classes et méthodes de Swing (seules quelques-unes sont montrées ici) ;
  2. Grâce aux conventions de nommage utilisées pour les événements Swing, il est facile de deviner comment écrire et installer un gestionnaire d'un événement de type donné. Utilisez le programme de recherche ShowAddListeners.java introduit plus avant dans ce chapitre pour faciliter votre investigation d'un composant particulier ;
  3. Lorsque les choses deviendront compliquées, passez à un GUI builder.

XV-H-1. Boutons

Swing comprend un certain nombre de boutons de différents types. Tous les boutons, boîtes à cocher [check boxes], boutons radio [radio buttons], et même les éléments de menus [menu items] héritent de AbstractButton(qui, vu qu'ils comprennent les éléments de menus, auraient probablement été mieux nommés AbstractChooser ou quelque chose du genre). Nous verrons l'utilisation des éléments de menus bientôt, mais l'exemple suivant montre les différents types de boutons existants :

 
Sélectionnez
//: c13:Buttons.java
// Divers boutons Swing.
// <applet code=Buttons
//&#160;&#160;width=350 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.plaf.basic.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;

public class Buttons extends JApplet {
JButton jb = new JButton("JButton");
BasicArrowButton
up = new BasicArrowButton(
BasicArrowButton.NORTH),
down = new BasicArrowButton(
BasicArrowButton.SOUTH),
right = new BasicArrowButton(
BasicArrowButton.EAST),
left = new BasicArrowButton(
BasicArrowButton.WEST);
&#160;&#160;public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(jb);
cp.add(new JToggleButton("JToggleButton"));
cp.add(new JCheckBox("JCheckBox"));
cp.add(new JRadioButton("JRadioButton"));
JPanel jp = new JPanel();
jp.setBorder(new TitledBorder("Directions"));
jp.add(up);
jp.add(down);
jp.add(left);
jp.add(right);
cp.add(jp);
}
&#160;&#160;public static void main(String[] args) {
Console.run(new Buttons(), 350, 100);
}
} ///:~

On commence par le BasicArrowButtonde javax.swing.plaf.basic, puis on continue avec les divers types de boutons. Si vous exécutez cet exemple, vous verrez que le toggle button (bouton inverseur) garde sa dernière position, enfoncé ou relâché. Mais les boîtes à cocher et les boutons radio se comportent de manière identique, on les clique pour les (dé)sélectionner (ils sont hérités de JToggleButton).

XV-H-1-a. Groupes de boutons

Si on désire des boutons radio qui se comportent selon un "ou exclusif", il faut les ajouter à un groupe de boutons. Mais, comme l'exemple ci-dessous le montre, tout AbstractButton peut être ajouté à un ButtonGroup.

Pour éviter de répéter beaucoup de code, cet exemple utilise la réflexion pour générer les groupes de différents types de boutons. Ceci peut se voir dans makeBPanel(), qui crée un groupe de boutons et un JPanel. Le second argument de makeBPanel() est un tableau de String. Pour chaque String, un bouton de la classe désignée par le premier argument est ajouté au JPanel :

 
Sélectionnez
//: c13:ButtonGroups.java
// Utilise la réflexion pour créer des groupes 
// de différents types de AbstractButton.
// <applet code=ButtonGroups
//&#160;&#160;width=500 height=300></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import java.lang.reflect.*;
import com.bruceeckel.swing.*;

public class ButtonGroups extends JApplet {
&#160;&#160;static String[] ids = { 
&#160;&#160; "June", "Ward", "Beaver", 
&#160;&#160; "Wally", "Eddie", "Lumpy",
};
&#160;&#160;static JPanel 
makeBPanel(Class bClass, String[] ids) {
ButtonGroup bg = new ButtonGroup();
JPanel jp = new JPanel();
String title = bClass.getName();
title = title.substring(
title.lastIndexOf('.') + 1);
jp.setBorder(new TitledBorder(title));
&#160;&#160; for(int i = 0; i AbstractButton ab = new JButton("failed");
&#160;&#160;&#160;&#160;try {
&#160;&#160;&#160;&#160; // Obtient la méthode de construction dynamique
&#160;&#160;&#160;&#160; // qui demande un argument String :
&#160;&#160; Constructor ctor = bClass.getConstructor(
&#160;&#160;&#160;&#160;&#160;&#160;new Class[] { String.class });
&#160;&#160;&#160;&#160; // Creation d'un nouvel objet :
&#160;&#160; ab = (AbstractButton)ctor.newInstance(
&#160;&#160;&#160;&#160;&#160;&#160;new Object[]{ids[i]});
} catch(Exception ex) {
&#160;&#160; System.err.println("can't create " + 
&#160;&#160;&#160;&#160; bClass);
}
bg.add(ab);
jp.add(ab);
}
&#160;&#160; return jp;
}
&#160;&#160;public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(makeBPanel(JButton.class, ids));
cp.add(makeBPanel(JToggleButton.class, ids));
cp.add(makeBPanel(JCheckBox.class, ids));
cp.add(makeBPanel(JRadioButton.class, ids));
}
&#160;&#160;public static void main(String[] args) {
Console.run(new ButtonGroups(), 500, 300);
}
} ///:~

Ceci ajoute un peu de complexité à ce qui est un processus simple. Pour obtenir un comportement de "OU exclusif" avec des boutons, on crée un groupe de boutons et on ajoute au groupe chaque bouton pour lequel on désire ce comportement. Lorsqu'on exécute le programme, on voit que tous les boutons, à l'exception de JButton, montrent ce comportement de "OU exclusif".

XV-H-2. Icônes

On peut utiliser un Icon dans un JLabel ou tout ce qui hérite de AbstractButton (y compris JButton, JCheckBox, JRadioButton, et les différents types de JMenuItem). L'utilisation d'Icons avec des JLabels est assez directe (on verra un exemple plus tard). L'exemple suivant explore toutes les façons d'utiliser des Icons avec des boutons et leurs descendants.

Vous pouvez utiliser les fichiers gif que vous voulez, mais ceux utilisés dans cet exemple font partie de la livraison du code de ce livre, disponible à www.BruceEckel.com. Pour ouvrir un fichier et utiliser l'image, il suffit de créer un ImageIcon et de lui fournir le nom du fichier. À partir de là on peut utiliser l'Icon obtenu dans le programme.

Remarquez que l'information de chemin est codée en dur dans cet exemple ; vous devrez changer ce chemin pour qu'il corresponde à l'emplacement des fichiers des images.

 
Sélectionnez
//: c13:Faces.java
// Comportement des Icones dans des&#160;&#160;Jbuttons.
// <applet code=Faces
//&#160;&#160;width=250 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class Faces extends JApplet {
&#160;&#160;// L'information de chemin suivante est nécessaire
&#160;&#160;// pour l'exécution via une applet directement depuis le disque :
&#160;&#160;static String path = 
&#160;&#160; "C:/aaa-TIJ2-distribution/code/c13/";
&#160;&#160;static Icon[] faces = {
&#160;&#160; new ImageIcon(path + "face0.gif"),
&#160;&#160; new ImageIcon(path + "face1.gif"),
&#160;&#160; new ImageIcon(path + "face2.gif"),
&#160;&#160; new ImageIcon(path + "face3.gif"),
&#160;&#160; new ImageIcon(path + "face4.gif"),
};
JButton 
jb = new JButton("JButton", faces[3]),
jb2 = new JButton("Disable");
&#160;&#160;boolean mad = false;
&#160;&#160;public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
jb.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160; if(mad) {
&#160;&#160;&#160;&#160; jb.setIcon(faces[3]);
&#160;&#160;&#160;&#160; mad = false;
&#160;&#160; } else {
&#160;&#160;&#160;&#160; jb.setIcon(faces[0]);
&#160;&#160;&#160;&#160; mad = true;
&#160;&#160; }
&#160;&#160; jb.setVerticalAlignment(JButton.TOP);
&#160;&#160; jb.setHorizontalAlignment(JButton.LEFT);
}
});
jb.setRolloverEnabled(true);
jb.setRolloverIcon(faces[1]);
jb.setPressedIcon(faces[2]);
jb.setDisabledIcon(faces[4]);
jb.setToolTipText("Yow!");
cp.add(jb);
jb2.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160; if(jb.isEnabled()) {
&#160;&#160;&#160;&#160; jb.setEnabled(false);
&#160;&#160;&#160;&#160; jb2.setText("Enable");
&#160;&#160; } else {
&#160;&#160;&#160;&#160; jb.setEnabled(true);
&#160;&#160;&#160;&#160; jb2.setText("Disable");
&#160;&#160; }
}
});
cp.add(jb2);
}
&#160;&#160;public static void main(String[] args) {
Console.run(new Faces(), 400, 200);
}
} ///:~

Un Icon peut être utilisé dans de nombreux constructeurs, mais on peut aussi utiliser setIcon() pour ajouter ou changer un Icon. Cet exemple montre également comment un JButton (ou un quelconque AbstractButton) peut positionner les différentes sortes d'icônes qui apparaissent lorsque des choses se passent sur ce bouton : lorsqu'il est enfoncé, invalidé, ou lorsqu'on roule par-dessus [rolled over] (la souris passe au-dessus sans cliquer). On verra que ceci donne au bouton une sensation d'animation agréable.

XV-H-3. Infobulles [Tooltips]

L'exemple précédent ajoutait un tool tip au bouton. La plupart des classes qu'on utilisera pour créer une interface utilisateur sont dérivées de JComponent, qui contient une méthode appelée setToolTipText(String). Donc pratiquement pour tout ce qu'on place sur un formulaire, il suffit de dire (pour un objet jc de toute classe dérivée de JComponent) :

 
Sélectionnez
jc.setToolTipText("My tip");

et lorsque la souris reste au-dessus de ce JComponent pour un temps prédéterminé, une petite boîte contenant le texte va apparaître à côté de la souris.

XV-H-4. Champs de texte [Text Fields]

Cet exemple montre le comportement supplémentaire dont sont capables les JTextFields :

 
Sélectionnez
//: c13:TextFields.java
// Champs de texte et événements Java.
// <applet code=TextFields width=375
// height=125></applet>
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class TextFields extends JApplet {
JButton
b1 = new JButton("Get Text"),
b2 = new JButton("Set Text");
JTextField
t1 = new JTextField(30),
t2 = new JTextField(30),
t3 = new JTextField(30);
String s = new String();
UpperCaseDocument
ucd = new UpperCaseDocument();
&#160;&#160;public void init() {
t1.setDocument(ucd);
ucd.addDocumentListener(new T1());
b1.addActionListener(new B1());
b2.addActionListener(new B2());
DocumentListener dl = new T1();
t1.addActionListener(new T1A());
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
cp.add(t1);
cp.add(t2);
cp.add(t3);
}
&#160;&#160;class T1 implements DocumentListener {
&#160;&#160; public void changedUpdate(DocumentEvent e){}
&#160;&#160; public void insertUpdate(DocumentEvent e){
t2.setText(t1.getText());
t3.setText("Text: "+ t1.getText());
}
&#160;&#160; public void removeUpdate(DocumentEvent e){
t2.setText(t1.getText());
}
}
&#160;&#160;class T1A implements ActionListener {
&#160;&#160; private int count = 0;
&#160;&#160; public void actionPerformed(ActionEvent e) {
t3.setText("t1 Action Event " + count++);
}
}
&#160;&#160;class B1 implements ActionListener {
&#160;&#160; public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;if(t1.getSelectedText() == null)
&#160;&#160; s = t1.getText();
&#160;&#160;&#160;&#160;else
&#160;&#160; s = t1.getSelectedText();
t1.setEditable(true);
}
}
&#160;&#160;class B2 implements ActionListener {
&#160;&#160; public void actionPerformed(ActionEvent e) {
ucd.setUpperCase(false);
t1.setText("Inserted by Button 2: " + s);
ucd.setUpperCase(true);
t1.setEditable(false);
}
}
&#160;&#160;public static void main(String[] args) {
Console.run(new TextFields(), 375, 125);
}
}

class UpperCaseDocument extends PlainDocument {
&#160;&#160;boolean upperCase = true;
&#160;&#160;public void setUpperCase(boolean flag) {
upperCase = flag;
}
&#160;&#160;public void insertString(int offset, 
String string, AttributeSet attributeSet)
&#160;&#160; throws BadLocationException {
&#160;&#160;&#160;&#160;if(upperCase)
&#160;&#160; string = string.toUpperCase();
&#160;&#160;&#160;&#160;super.insertString(offset, 
&#160;&#160; string, attributeSet);
}
} ///:~

Le JTextField t3 est inclus pour servir d'emplacement pour signaler lorsque l'action listener du JTextField t1 est lancé. On verra que l'action listener d'un JTextField n'est lancée que lorsqu'on appuie sur la touche enter.

Le JTextField t1 a plusieurs listeners attachés. le listener T1 est un Document Listener qui répond à tout changement dans le document (le contenu du JTextField, dans ce cas). Il copie automatiquement tout le texte de t1 dans t2. De plus, le document t1 est positionné à une classe dérivée de PlainDocument, appelée UpperCaseDocument, qui force tous les caractères en majuscules. Il détecte automatiquement les retours en arrière [backspaces] et effectue l'effacement, tout en ajustant le curseur et gérant tout de la manière attendue.

XV-H-5. Bordures

JComponent possède une méthode appelée setBorder(), qui permet de placer différentes bordures intéressantes sur tout composant visible. L'exemple suivant montre certaines des bordures existantes, en utilisant la méthode showBorder() qui crée un JPanel et lui attache une bordure à chaque fois. Il utilise aussi RTTI pour trouver le nom de la bordure qu'on utilise (en enlevant l'information du chemin), et met ensuite le nom dans un JLabel au milieu du panneau :

 
Sélectionnez
//: c13:Borders.java
// Diverses bordures Swing.
// <applet code=Borders
//&#160;&#160;width=500 height=300></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;

public class Borders extends JApplet {
&#160;&#160;static JPanel showBorder(Border b) {
&#160;&#160;&#160;&#160;JPanel jp = new JPanel();
&#160;&#160;&#160;&#160;jp.setLayout(new BorderLayout());
&#160;&#160;&#160;&#160;String nm = b.getClass().toString();
&#160;&#160;&#160;&#160;nm = nm.substring(nm.lastIndexOf('.') + 1);
&#160;&#160;&#160;&#160;jp.add(new JLabel(nm, JLabel.CENTER), 
&#160;&#160;&#160;&#160;&#160;&#160;BorderLayout.CENTER);
&#160;&#160;&#160;&#160;jp.setBorder(b);
&#160;&#160;&#160;&#160;return jp;
&#160;&#160;}
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.setLayout(new GridLayout(2,4));
&#160;&#160;&#160;&#160;cp.add(showBorder(new TitledBorder("Title")));
&#160;&#160;&#160;&#160;cp.add(showBorder(new EtchedBorder()));
&#160;&#160;&#160;&#160;cp.add(showBorder(new LineBorder(Color.blue)));
&#160;&#160;&#160;&#160;cp.add(showBorder(
&#160;&#160;&#160;&#160;&#160;&#160;new MatteBorder(5,5,30,30,Color.green)));
&#160;&#160;&#160;&#160;cp.add(showBorder(
&#160;&#160;&#160;&#160;&#160;&#160;new BevelBorder(BevelBorder.RAISED)));
&#160;&#160;&#160;&#160;cp.add(showBorder(
&#160;&#160;&#160;&#160;&#160;&#160;new SoftBevelBorder(BevelBorder.LOWERED)));
&#160;&#160;&#160;&#160;cp.add(showBorder(new CompoundBorder(
&#160;&#160;&#160;&#160;&#160;&#160;new EtchedBorder(),
&#160;&#160;&#160;&#160;&#160;&#160;new LineBorder(Color.red))));
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new Borders(), 500, 300);
&#160;&#160;}
} ///:~

On peut également créer ses propres bordures et les placer dans des boutons, labels, etc. tout ce qui est dérivé de JComponent.

XV-H-6. JScrollPanes

La plupart du temps on laissera le JScrollPane tel quel, mais on peut aussi contrôler quelles barres de défilement sont autorisées, verticales, horizontales, les deux ou ni l'une ni l'autre :

 
Sélectionnez
//: c13:JScrollPanes.java
// Contrôle des scrollbars d'un JScrollPane.
// <applet code=JScrollPanes width=300 height=725>
// </applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;

public class JScrollPanes extends JApplet {
&#160;&#160;JButton 
&#160;&#160;&#160;&#160;b1 = new JButton("Text Area 1"),
&#160;&#160;&#160;&#160;b2 = new JButton("Text Area 2"),
&#160;&#160;&#160;&#160;b3 = new JButton("Replace Text"),
&#160;&#160;&#160;&#160;b4 = new JButton("Insert Text");
&#160;&#160;JTextArea 
&#160;&#160;&#160;&#160;t1 = new JTextArea("t1", 1, 20),
&#160;&#160;&#160;&#160;t2 = new JTextArea("t2", 4, 20),
&#160;&#160;&#160;&#160;t3 = new JTextArea("t3", 1, 20),
&#160;&#160;&#160;&#160;t4 = new JTextArea("t4", 10, 10),
&#160;&#160;&#160;&#160;t5 = new JTextArea("t5", 4, 20),
&#160;&#160;&#160;&#160;t6 = new JTextArea("t6", 10, 10);
&#160;&#160;JScrollPane 
&#160;&#160;&#160;&#160;sp3 = new JScrollPane(t3,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.VERTICAL_SCROLLBAR_NEVER,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.HORIZONTAL_SCROLLBAR_NEVER),
&#160;&#160;&#160;&#160;sp4 = new JScrollPane(t4,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.HORIZONTAL_SCROLLBAR_NEVER),
&#160;&#160;&#160;&#160;sp5 = new JScrollPane(t5,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.VERTICAL_SCROLLBAR_NEVER,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS),
&#160;&#160;&#160;&#160;sp6 = new JScrollPane(t6,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
&#160;&#160;&#160;&#160;&#160;&#160;JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
&#160;&#160;class B1L implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t5.append(t1.getText() + "\n");
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class B2L implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t2.setText("Inserted by Button 2");
&#160;&#160;&#160;&#160;&#160;&#160;t2.append(": " + t1.getText());
&#160;&#160;&#160;&#160;&#160;&#160;t5.append(t2.getText() + "\n");
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class B3L implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;String s = " Replacement ";
&#160;&#160;&#160;&#160;&#160;&#160;t2.replaceRange(s, 3, 3 + s.length());
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class B4L implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t2.insert(" Inserted ", 10);
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;// Création de Borders pour les composants:
&#160;&#160;&#160;&#160;Border brd = BorderFactory.createMatteBorder(
&#160;&#160;&#160;&#160;&#160;&#160;1, 1, 1, 1, Color.black);
&#160;&#160;&#160;&#160;t1.setBorder(brd);
&#160;&#160;&#160;&#160;t2.setBorder(brd);
&#160;&#160;&#160;&#160;sp3.setBorder(brd);
&#160;&#160;&#160;&#160;sp4.setBorder(brd);
&#160;&#160;&#160;&#160;sp5.setBorder(brd);
&#160;&#160;&#160;&#160;sp6.setBorder(brd);
&#160;&#160;&#160;&#160;// Initialisation des listeners et ajout des composants:
&#160;&#160;&#160;&#160;b1.addActionListener(new B1L());
&#160;&#160;&#160;&#160;cp.add(b1);
&#160;&#160;&#160;&#160;cp.add(t1);
&#160;&#160;&#160;&#160;b2.addActionListener(new B2L());
&#160;&#160;&#160;&#160;cp.add(b2);
&#160;&#160;&#160;&#160;cp.add(t2);
&#160;&#160;&#160;&#160;b3.addActionListener(new B3L());
&#160;&#160;&#160;&#160;cp.add(b3);
&#160;&#160;&#160;&#160;b4.addActionListener(new B4L());
&#160;&#160;&#160;&#160;cp.add(b4);
&#160;&#160;&#160;&#160;cp.add(sp3); 
&#160;&#160;&#160;&#160;cp.add(sp4); 
&#160;&#160;&#160;&#160;cp.add(sp5);
&#160;&#160;&#160;&#160;cp.add(sp6);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new JScrollPanes(), 300, 725);
&#160;&#160;}
} ///:~

L'utilisation des différents arguments du constructeur de JScrollPane contrôle la présence des scrollbars. Cet exemple est également un peu "habillé" à l'aide de bordures.

XV-H-7. Un miniéditeur

Le contrôle JTextPane fournit un support important pour l'édition de texte, sans grand effort. L'exemple suivant en fait une utilisation très simple, en ignorant le plus gros des fonctionnalités de la classe :

 
Sélectionnez
//: c13:TextPane.java
// Le contrôle JTextPane est un petit éditeur de texte.
// <applet code=TextPane width=475 height=425>
// </applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
import com.bruceeckel.util.*;

public class TextPane extends JApplet {
&#160;&#160;JButton b = new JButton("Add Text");
&#160;&#160;JTextPane tp = new JTextPane();
&#160;&#160;static Generator sg = 
&#160;&#160;&#160;&#160;new Arrays2.RandStringGenerator(7);&#160;&#160;
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;b.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;for(int i = 1; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;tp.setText(tp.getText() + 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;sg.next() + "\n");
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(new JScrollPane(tp));
&#160;&#160;&#160;&#160;cp.add(BorderLayout.SOUTH, b);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new TextPane(), 475, 425);
&#160;&#160;}
} ///:~

Le bouton ajoute simplement au hasard du texte généré. Le but du JTextPane est de permettre la modification de texte sur place, de sorte qu'on ne trouvera pas de méthode append(). Dans ce cas-ci (il est admis qu'il s'agit d'un piètre usage des capacités de JTextPane), le texte doit être saisi, modifié, et replacé dans le panneau en utilisant setText().

Remarquez les fonctionnalités intrinsèques du JTextPane, telles que le retour à la ligne automatique. Il y a de nombreuses autres fonctionnalités à découvrir dans la documentation du JDK.

XV-H-8. Boîtes à cocher [Check boxes]

Une boîte à cocher [check box] permet d'effectuer un choix simple vrai/faux ; il consiste en une petite boîte et un label. La boîte contient d'habitude un petit x (ou tout autre moyen d'indiquer qu'elle est cochée) ou est vide, selon qu'elle a été sélectionnée ou non.

On crée normalement une JCheckBox en utilisant un constructeur qui prend le label comme argument. On peut obtenir ou forcer l'état, et également obtenir ou forcer le label si on veut le lire ou le modifier après la création de la JCheckBox.

Chaque fois qu'une JCheckBox est remplie ou vidée, un événement est généré, qu'on peut capturer de la même façon que pour un bouton, en utilisant un ActionListener. L'exemple suivant utilise un JTextArea pour lister toutes les boîtes à cocher qui ont été cochées :

 
Sélectionnez
//: c13:CheckBoxes.java
// Utilisation des JCheckBoxes.
// <applet code=CheckBoxes width=200 height=200>
// </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class CheckBoxes extends JApplet {
&#160;&#160;JTextArea t = new JTextArea(6, 15);
&#160;&#160;JCheckBox 
&#160;&#160;&#160;&#160;cb1 = new JCheckBox("Check Box 1"),
&#160;&#160;&#160;&#160;cb2 = new JCheckBox("Check Box 2"),
&#160;&#160;&#160;&#160;cb3 = new JCheckBox("Check Box 3");
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;cb1.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;trace("1", cb1);
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;cb2.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;trace("2", cb2);
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;cb3.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;trace("3", cb3);
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(new JScrollPane(t));
&#160;&#160;&#160;&#160;cp.add(cb1); 
&#160;&#160;&#160;&#160;cp.add(cb2); 
&#160;&#160;&#160;&#160;cp.add(cb3);
&#160;&#160;}
&#160;&#160;void trace(String b, JCheckBox cb) {
&#160;&#160;&#160;&#160;if(cb.isSelected())
&#160;&#160;&#160;&#160;&#160;&#160;t.append("Box " + b + " Set\n");
&#160;&#160;&#160;&#160;else
&#160;&#160;&#160;&#160;&#160;&#160;t.append("Box " + b + " Cleared\n");
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new CheckBoxes(), 200, 200);
&#160;&#160;}
} ///:~

La méthode trace() envoie le nom et l'état de la JCheckBox sélectionnée au JTextArea en utilisant append(), de telle sorte qu'on voit une liste cumulative des boîtes à cocher qui ont été sélectionnées, et quel est leur état.

XV-H-9. Boutons radio

Le concept d'un bouton radio en programmation de GUI provient des autoradios d'avant l'ère électronique, avec des boutons mécaniques : quand on appuie sur l'un d'eux, tout autre bouton enfoncé est relâché. Ceci permet de forcer un choix unique parmi plusieurs.

Pour installer un groupe de JRadioButtons, il suffit de les ajouter à un ButtonGroup (il peut y avoir un nombre quelconque de ButtonGroups dans un formulaire). En utilisant le second argument du constructeur, on peut optionnellement forcer à true l'état d'un des boutons. Si on essaie de forcer à true plus d'un bouton radio, seul le dernier forcé sera à true.

Voici un exemple simple d'utilisation de boutons radio. On remarquera que les événements des boutons radio s'interceptent comme tous les autres :

 
Sélectionnez
//: c13:RadioButtons.java
// Utilisation des JRadioButtons.
// <applet code=RadioButtons 
// width=200 height=100> </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class RadioButtons extends JApplet {
&#160;&#160;JTextField t = new JTextField(15);
&#160;&#160;ButtonGroup g = new ButtonGroup();
&#160;&#160;JRadioButton 
&#160;&#160;&#160;&#160;rb1 = new JRadioButton("one", false),
&#160;&#160;&#160;&#160;rb2 = new JRadioButton("two", false),
&#160;&#160;&#160;&#160;rb3 = new JRadioButton("three", false);
&#160;&#160;ActionListener al = new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Radio button " + 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;((JRadioButton)e.getSource()).getText());
&#160;&#160;&#160;&#160;}
&#160;&#160;};
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;rb1.addActionListener(al);
&#160;&#160;&#160;&#160;rb2.addActionListener(al);
&#160;&#160;&#160;&#160;rb3.addActionListener(al);
&#160;&#160;&#160;&#160;g.add(rb1); g.add(rb2); g.add(rb3);
&#160;&#160;&#160;&#160;t.setEditable(false);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(t); 
&#160;&#160;&#160;&#160;cp.add(rb1); 
&#160;&#160;&#160;&#160;cp.add(rb2); 
&#160;&#160;&#160;&#160;cp.add(rb3); 
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new RadioButtons(), 200, 100);
&#160;&#160;}
} ///:~

Pour afficher l'état un champ texte est utilisé. Ce champ est déclaré non modifiable, car il est utilisé uniquement pour afficher des données et pas pour en recevoir. C'est une alternative à l'utilisation d'un JLabel.

XV-H-10. Boîtes combo (listes à ouverture vers le bas) [combo boxes (drop-down lists)]

Comme les groupes de boutons radio, une drop-down list est une façon de forcer l'utilisateur à choisir un seul élément parmi un groupe de possibilités. C'est cependant un moyen plus compact, et il est plus facile de modifier les éléments de la liste sans surprendre l'utilisateur (on peut modifier dynamiquement les boutons radio, mais ça peut devenir visuellement perturbant).

La JComboBox java n'est pas comme la combo box de Windows qui permet de sélectionner dans une liste ou de taper soi-même une sélection. Avec une JComboBox on choisit un et un seul élément de la liste. Dans l'exemple suivant, la JComboBox démarre avec un certain nombre d'éléments et ensuite des éléments sont ajoutés lorsqu'on appuie sur un bouton.

 
Sélectionnez
//: c13:ComboBoxes.java
// Utilisation des drop-down lists.
// <applet code=ComboBoxes
// width=200 height=100> </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class ComboBoxes extends JApplet {
&#160;&#160;String[] description = { "Ebullient", "Obtuse",
&#160;&#160;&#160;&#160;"Recalcitrant", "Brilliant", "Somnescent",
&#160;&#160;&#160;&#160;"Timorous", "Florid", "Putrescent" };
&#160;&#160;JTextField t = new JTextField(15);
&#160;&#160;JComboBox c = new JComboBox();
&#160;&#160;JButton b = new JButton("Add items");
&#160;&#160;int count = 0;
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;c.addItem(description[count++]);
&#160;&#160;&#160;&#160;t.setEditable(false);
&#160;&#160;&#160;&#160;b.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(count &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.addItem(description[count++]);
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;c.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("index: "+ c.getSelectedIndex()
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;+ "&#160;&#160; " + ((JComboBox)e.getSource())
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;.getSelectedItem());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(t);
&#160;&#160;&#160;&#160;cp.add(c);
&#160;&#160;&#160;&#160;cp.add(b);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new ComboBoxes(), 200, 100);
&#160;&#160;}
} ///:~

Le JTextField affiche l'index sélectionné, qui est le numéro séquentiel de l'élément sélectionné, ainsi que le label du bouton radio.

XV-H-11. Listes [List boxes]

Les listes sont différentes des JComboBox, et pas seulement en apparence. Alors qu'une JComboBox s'affiche vers le bas lorsqu'on l'active, une JList occupe un nombre fixe de lignes sur l'écran tout le temps et ne se modifie pas. Si on veut voir les éléments de la liste, il suffit d'appeler getSelectedValues(), qui retourne un tableau de String des éléments sélectionnés.

Une JList permet la sélection multiple : si on "control-clique" sur plus d'un élément (en enfonçant la touche control tout en effectuant des clics souris) l'élément initial reste surligné et on peut en sélectionner autant qu'on veut. Si on sélectionne un élément puis qu'on en "shift-clique" un autre, tous les éléments entre ces deux-là seront aussi sélectionnés. Pour supprimer un élément d'un groupe on peut le "control-cliquer".

 
Sélectionnez
//: c13:List.java
// <applet code=List width=250
// height=375> </applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;

public class List extends JApplet {
&#160;&#160;String[] flavors = { "Chocolate", "Strawberry",
&#160;&#160;&#160;&#160;"Vanilla Fudge Swirl", "Mint Chip",
&#160;&#160;&#160;&#160;"Mocha Almond Fudge", "Rum Raisin",
&#160;&#160;&#160;&#160;"Praline Cream", "Mud Pie" };
&#160;&#160;DefaultListModel lItems=new DefaultListModel();
&#160;&#160;JList lst = new JList(lItems);
&#160;&#160;JTextArea t = new JTextArea(flavors.length,20);
&#160;&#160;JButton b = new JButton("Add Item");
&#160;&#160;ActionListener bl = new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;if(count &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;lItems.add(0, flavors[count++]);
&#160;&#160;&#160;&#160;&#160;&#160;} else {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;// Invalider, puisqu'il n'y a plus
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;// de parfums à ajouter à la liste
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;b.setEnabled(false);
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;};
&#160;&#160;ListSelectionListener ll =&#160;&#160;&#160;&#160;new ListSelectionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void valueChanged(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;ListSelectionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Object[] items=lst.getSelectedValues();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.append(items[i] + "\n");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;};
&#160;&#160;int count = 0;
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;t.setEditable(false);
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;// Création de Bords pour les composants:
&#160;&#160;&#160;&#160;Border brd = BorderFactory.createMatteBorder(
&#160;&#160;&#160;&#160;&#160;&#160;1, 1, 2, 2, Color.black);
&#160;&#160;&#160;&#160;lst.setBorder(brd);
&#160;&#160;&#160;&#160;t.setBorder(brd);
&#160;&#160;&#160;&#160;// Ajout des quatre premiers éléments à la liste
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;lItems.addElement(flavors[count++]);
&#160;&#160;&#160;&#160;// Ajout des éléments au Content Pane pour affichage
&#160;&#160;&#160;&#160;cp.add(t);
&#160;&#160;&#160;&#160;cp.add(lst);
&#160;&#160;&#160;&#160;cp.add(b);
&#160;&#160;&#160;&#160;// Enregistrement des listeners d'événements
&#160;&#160;&#160;&#160;lst.addListSelectionListener(ll);
&#160;&#160;&#160;&#160;b.addActionListener(bl);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new List(), 250, 375);
&#160;&#160;}
} ///:~

Quand on appuie sur le bouton, il ajoute des éléments au début de la liste (car le second argument de addItem() est 0).

On peut également voir qu'une bordure a été ajoutée aux listes.

Si on veut simplement mettre un tableau de Strings dans une JList, il y a une solution beaucoup plus simple : passer le tableau au constructeur de la JList, et il construit la liste automatiquement. La seule raison d'utiliser le modèle de liste de l'exemple ci-dessus est que la liste peut être manipulée lors de l'exécution du programme.

Les JLists ne fournissent pas de support direct pour le scrolling. Bien évidemment, il suffit d'encapsuler la JList dans une JScrollPane et tous les détails sont automatiquement gérés.

XV-H-12. Panneaux à tabulations [Tabbed panes]

Les JTabbedPane permettent de créer un dialogue tabulé, avec sur un côté des tabulations semblables à celles de classeurs de fiches, permettant d'amener au premier plan un autre dialogue en cliquant sur l'une d'entre elles.

 
Sélectionnez
//: c13:TabbedPane1.java
// Démonstration de Tabbed Pane.
// <applet code=TabbedPane1 
// width=350 height=200> </applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class TabbedPane1 extends JApplet {
&#160;&#160;String[] flavors = { "Chocolate", "Strawberry",
&#160;&#160;&#160;&#160;"Vanilla Fudge Swirl", "Mint Chip", 
&#160;&#160;&#160;&#160;"Mocha Almond Fudge", "Rum Raisin", 
&#160;&#160;&#160;&#160;"Praline Cream", "Mud Pie" };
&#160;&#160;JTabbedPane tabs = new JTabbedPane();
&#160;&#160;JTextField txt = new JTextField(20);
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;tabs.addTab(flavors[i], 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;new JButton("Tabbed pane " + i));
&#160;&#160;&#160;&#160;tabs.addChangeListener(new ChangeListener(){
&#160;&#160;&#160;&#160;&#160;&#160;public void stateChanged(ChangeEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;txt.setText("Tab selected: " + 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;tabs.getSelectedIndex());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(BorderLayout.SOUTH, txt);
&#160;&#160;&#160;&#160;cp.add(tabs);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new TabbedPane1(), 350, 200);
&#160;&#160;}
} ///:~

En Java, l'utilisation d'un mécanisme de panneaux à tabulations est importante, car pour la programmation d'applets, l'utilisation de dialogues pop-ups est découragée par l'apparition automatique d'un petit avertissement à chaque dialogue qui surgit d'une applet.

Lors de l'exécution de ce programme on remarquera que le JTabbedPane empile automatiquement les tabulations s'il y en a trop pour une rangée. On peut s'en apercevoir en redimensionnant la fenêtre lorsque le programme est lancé depuis la ligne de commande.

XV-H-13. Boîtes de messages

Les environnements de fenêtrage comportent classiquement un ensemble standard de boîtes de messages qui permettent d'afficher rapidement une information à l'utilisateur, ou lui demander une information. Dans Swing, ces boîtes de messages sont contenues dans les JOptionPanes. Il y a de nombreuses possibilités (certaines assez sophistiquées), mais celles qu'on utilise le plus couramment sont les messages et les confirmations, appelées en utilisant static JOptionPane.showMessageDialog() et JOptionPane.showConfirmDialog(). L'exemple suivant montre un sous-ensemble des boîtes de messages disponibles avec JOptionPane :

 
Sélectionnez
//: c13:MessageBoxes.java
// Démonstration de JoptionPane.
// <applet code=MessageBoxes 
// width=200 height=150> </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class MessageBoxes extends JApplet {
&#160;&#160;JButton[] b = { new JButton("Alert"), 
&#160;&#160;&#160;&#160;new JButton("Yes/No"), new JButton("Color"),
&#160;&#160;&#160;&#160;new JButton("Input"), new JButton("3 Vals")
&#160;&#160;};
&#160;&#160;JTextField txt = new JTextField(15);
&#160;&#160;ActionListener al = new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;String id = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;((JButton)e.getSource()).getText();
&#160;&#160;&#160;&#160;&#160;&#160;if(id.equals("Alert"))
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.showMessageDialog(null, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"There's a bug on you!", "Hey!", 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.ERROR_MESSAGE);
&#160;&#160;&#160;&#160;&#160;&#160;else if(id.equals("Yes/No"))
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.showConfirmDialog(null, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"or no", "choose yes", 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.YES_NO_OPTION);
&#160;&#160;&#160;&#160;&#160;&#160;else if(id.equals("Color")) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Object[] options = { "Red", "Green" };
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int sel = JOptionPane.showOptionDialog(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;null, "Choose a Color!", "Warning", 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.DEFAULT_OPTION, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.WARNING_MESSAGE, null, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;options, options[0]);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(sel != JOptionPane.CLOSED_OPTION)
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;txt.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"Color Selected: " + options[sel]);
&#160;&#160;&#160;&#160;&#160;&#160;} else if(id.equals("Input")) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;String val = JOptionPane.showInputDialog(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"How many fingers do you see?"); 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;txt.setText(val);
&#160;&#160;&#160;&#160;&#160;&#160;} else if(id.equals("3 Vals")) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Object[] selections = {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"First", "Second", "Third" };
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Object val = JOptionPane.showInputDialog(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;null, "Choose one", "Input",
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;JOptionPane.INFORMATION_MESSAGE, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;null, selections, selections[0]);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(val != null)
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;txt.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;val.toString());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;};
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;b[i].addActionListener(al);
&#160;&#160;&#160;&#160;&#160;&#160;cp.add(b[i]);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;cp.add(txt);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new MessageBoxes(), 200, 200);
&#160;&#160;}
} ///:~

On remarquera que showOptionDialog() et showInputDialog() retournent des objets contenant la valeur entrée par l'utilisateur.

XV-H-14. Menus

Chaque composant capable de contenir un menu, y compris JApplet, JFrame, JDialog et leurs descendants, possède une méthode setJMenuBar() qui prend comme paramètre un JMenuBar (il ne peut y avoir qu'un seul JMenuBar sur un composant donné). On ajoute les JMenus au JMenuBar, et les JMenuItems aux JMenus. On peut attacher un ActionListener à chaque JMenuItem, qui sera lancé quand l'élément de menu est sélectionné.

Contrairement à un système qui utilise des ressources, en Java et Swing il faut assembler à la main tous les menus dans le code source. Voici un exemple très simple de menu :

 
Sélectionnez
//: c13:SimpleMenus.java
// <applet code=SimpleMenus 
// width=200 height=75> </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

public class SimpleMenus extends JApplet {
&#160;&#160;JTextField t = new JTextField(15);
&#160;&#160;ActionListener al = new ActionListener() {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;t.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;((JMenuItem)e.getSource()).getText());
&#160;&#160;&#160;&#160;}
&#160;&#160;};
&#160;&#160;JMenu[] menus = { new JMenu("Winken"), 
&#160;&#160;&#160;&#160;new JMenu("Blinken"), new JMenu("Nod") };
&#160;&#160;JMenuItem[] items = {
&#160;&#160;&#160;&#160;new JMenuItem("Fee"), new JMenuItem("Fi"),
&#160;&#160;&#160;&#160;new JMenuItem("Fo"),&#160;&#160;new JMenuItem("Zip"),
&#160;&#160;&#160;&#160;new JMenuItem("Zap"), new JMenuItem("Zot"), 
&#160;&#160;&#160;&#160;new JMenuItem("Olly"), new JMenuItem("Oxen"),
&#160;&#160;&#160;&#160;new JMenuItem("Free") };
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;items[i].addActionListener(al);
&#160;&#160;&#160;&#160;&#160;&#160;menus[i%3].add(items[i]);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;JMenuBar mb = new JMenuBar();
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;mb.add(menus[i]);
&#160;&#160;&#160;&#160;setJMenuBar(mb);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(t); 
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new SimpleMenus(), 200, 75);
&#160;&#160;}
} ///:~

L'utilisation de l'opérateur modulo [modulus] dans i%3 distribue les éléments de menus parmi les trois JMenus. Chaque JMenuItem doit avoir un ActionListener attaché ; ici le même ActionListener est utilisé partout, mais on en aura besoin normalement d'un pour chaque JMenuItem.

JMenuItem hérite d'AbstractButton, et il a donc certains comportements des boutons. En lui-même, il fournit un élément qui peut être placé dans un menu déroulant. Il y a aussi trois types qui héritent de JMenuItem : JMenu pour contenir d'autres JMenuItems (pour réaliser des menus en cascade), JCheckBoxMenuItem, qui fournit un marquage pour indiquer si l'élément de menu est sélectionné ou pas, et JRadioButtonMenuItem, qui contient un bouton radio.

En tant qu'exemple plus sophistiqué, voici à nouveau les parfums de crèmes glacées, utilisés pour créer des menus. Cet exemple montre également des menus en cascade, des mnémoniques clavier, des JCheckBoxMenuItems, et la façon de changer ces menus dynamiquement :

 
Sélectionnez
//: c13:Menus.java
// Sous-menus, éléments de menu avec boîtes à cocher, permutations de&#160;&#160;menus,
// mnémoniques (raccourcis) et commandes d'actions.
// <applet code=Menus width=300
// height=100> </applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class Menus extends JApplet {
&#160;&#160;String[] flavors = { "Chocolate", "Strawberry",
&#160;&#160;&#160;&#160;"Vanilla Fudge Swirl", "Mint Chip", 
&#160;&#160;&#160;&#160;"Mocha Almond Fudge", "Rum Raisin", 
&#160;&#160;&#160;&#160;"Praline Cream", "Mud Pie" };
&#160;&#160;JTextField t = new JTextField("No flavor", 30);
&#160;&#160;JMenuBar mb1 = new JMenuBar();
&#160;&#160;JMenu 
&#160;&#160;&#160;&#160;f = new JMenu("File"),
&#160;&#160;&#160;&#160;m = new JMenu("Flavors"),
&#160;&#160;&#160;&#160;s = new JMenu("Safety");
&#160;&#160;// Approche alternative :
&#160;&#160;JCheckBoxMenuItem[] safety = {
&#160;&#160;&#160;&#160;new JCheckBoxMenuItem("Guard"),
&#160;&#160;&#160;&#160;new JCheckBoxMenuItem("Hide")
&#160;&#160;};
&#160;&#160;JMenuItem[] file = {
&#160;&#160;&#160;&#160;new JMenuItem("Open"),
&#160;&#160;};
&#160;&#160;// Une seconde barre de menu pour échanger :
&#160;&#160;JMenuBar mb2 = new JMenuBar();
&#160;&#160;JMenu fooBar = new JMenu("fooBar");
&#160;&#160;JMenuItem[] other = {
&#160;&#160;&#160;&#160;// Ajouter un raccourci de menu (mnémonique) est très 
&#160;&#160;&#160;&#160;// simple, mais seuls les JMenuItems peuvent les avoir 
&#160;&#160;&#160;&#160;// dans leurs constructeurs:
&#160;&#160;&#160;&#160;new JMenuItem("Foo", KeyEvent.VK_F),
&#160;&#160;&#160;&#160;new JMenuItem("Bar", KeyEvent.VK_A),
&#160;&#160;&#160;&#160;// Pas de raccourci :
&#160;&#160;&#160;&#160;new JMenuItem("Baz"),
&#160;&#160;};
&#160;&#160;JButton b = new JButton("Swap Menus");
&#160;&#160;class BL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JMenuBar m = getJMenuBar();
&#160;&#160;&#160;&#160;&#160;&#160;setJMenuBar(m == mb1 ? mb2 : mb1);
&#160;&#160;&#160;&#160;&#160;&#160;validate(); // Rafraîchissement de la fenêtre
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class ML implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JMenuItem target = (JMenuItem)e.getSource();
&#160;&#160;&#160;&#160;&#160;&#160;String actionCommand = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;target.getActionCommand();
&#160;&#160;&#160;&#160;&#160;&#160;if(actionCommand.equals("Open")) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;String s = t.getText();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;boolean chosen = false;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(s.equals(flavors[i])) chosen = true;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(!chosen)
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Choose a flavor first!");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;else
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Opening "+ s +". Mmm, mm!");
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class FL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JMenuItem target = (JMenuItem)e.getSource();
&#160;&#160;&#160;&#160;&#160;&#160;t.setText(target.getText());
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;// Alternativement, on peut créer une classe
// différente pour chaque JMenuItem. Ensuite
// il n'est plus nécessaire de rechercher de laquelle il s'agit :
&#160;&#160;class FooL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Foo selected");
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class BarL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Bar selected");
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class BazL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Baz selected");
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class CMIL implements ItemListener {
&#160;&#160;&#160;&#160;public void itemStateChanged(ItemEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JCheckBoxMenuItem target = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;(JCheckBoxMenuItem)e.getSource();
&#160;&#160;&#160;&#160;&#160;&#160;String actionCommand = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;target.getActionCommand();
&#160;&#160;&#160;&#160;&#160;&#160;if(actionCommand.equals("Guard"))
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Guard the Ice Cream! " +
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"Guarding is " + target.getState());
&#160;&#160;&#160;&#160;&#160;&#160;else if(actionCommand.equals("Hide"))
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText("Hide the Ice Cream! " +
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;"Is it cold? " + target.getState());
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;ML ml = new ML();
&#160;&#160;&#160;&#160;CMIL cmil = new CMIL();
&#160;&#160;&#160;&#160;safety[0].setActionCommand("Guard");
&#160;&#160;&#160;&#160;safety[0].setMnemonic(KeyEvent.VK_G);
&#160;&#160;&#160;&#160;safety[0].addItemListener(cmil);
&#160;&#160;&#160;&#160;safety[1].setActionCommand("Hide");
&#160;&#160;&#160;&#160;safety[0].setMnemonic(KeyEvent.VK_H);
&#160;&#160;&#160;&#160;safety[1].addItemListener(cmil);
&#160;&#160;&#160;&#160;other[0].addActionListener(new FooL());
&#160;&#160;&#160;&#160;other[1].addActionListener(new BarL());
&#160;&#160;&#160;&#160;other[2].addActionListener(new BazL());
&#160;&#160;&#160;&#160;FL fl = new FL();
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;JMenuItem mi = new JMenuItem(flavors[i]);
&#160;&#160;&#160;&#160;&#160;&#160;mi.addActionListener(fl);
&#160;&#160;&#160;&#160;&#160;&#160;m.add(mi);
&#160;&#160;&#160;&#160;&#160;&#160;// Ajout de séparateurs par&#160;&#160;intervalles:
&#160;&#160;&#160;&#160;&#160;&#160;if((i+1) % 3 == 0) 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;m.addSeparator();
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;s.add(safety[i]);
&#160;&#160;&#160;&#160;s.setMnemonic(KeyEvent.VK_A);
&#160;&#160;&#160;&#160;f.add(s);
&#160;&#160;&#160;&#160;f.setMnemonic(KeyEvent.VK_F);
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;file[i].addActionListener(fl);
&#160;&#160;&#160;&#160;&#160;&#160;f.add(file[i]);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;mb1.add(f);
&#160;&#160;&#160;&#160;mb1.add(m);
&#160;&#160;&#160;&#160;setJMenuBar(mb1);
&#160;&#160;&#160;&#160;t.setEditable(false);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(t, BorderLayout.CENTER);
&#160;&#160;&#160;&#160;// Installation du système d'échange de menus:
&#160;&#160;&#160;&#160;b.addActionListener(new BL());
&#160;&#160;&#160;&#160;b.setMnemonic(KeyEvent.VK_S);
&#160;&#160;&#160;&#160;cp.add(b, BorderLayout.NORTH);
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;fooBar.add(other[i]);
&#160;&#160;&#160;&#160;fooBar.setMnemonic(KeyEvent.VK_B);
&#160;&#160;&#160;&#160;mb2.add(fooBar);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new Menus(), 300, 100);
&#160;&#160;}
} ///:~

Dans ce programme, j'ai placé les éléments de menus dans des tableaux et ensuite j'ai parcouru chaque tableau en appelant add() pour chaque JMenuItem. Ceci rend l'ajout ou la suppression d'un élément de menu un peu moins fastidieux.

Ce programme crée deux JMenuBars pour démontrer que les barres de menu peuvent être échangées dynamiquement à l'exécution du programme. On peut voir qu'un JMenuBar est composé de JMenus, et que chaque JMenu est composé de JMenuItems, JCheckBoxMenuItems, ou même d'autres JMenus (qui produisent des sous-menus). Une fois construit un JMenuBar, il peut être installé dans le programme courant avec la méthode setJMenuBar(). Remarquons que lorsque le bouton est cliqué, il regarde quel menu est installé en appelant getJMenuBar(), et à ce moment il le remplace par l'autre barre de menu.

Lorsqu'on teste "Open", il faut remarquer que l'orthographe et les majuscules/minuscules sont cruciaux, et que Java ne signale pas d'erreur s'il n'y a pas correspondance avec "Open". Ce genre de comparaison de chaînes est une source d'erreurs de programmation.

Le cochage et le décochage des éléments de menus sont pris en compte automatiquement. Le code gérant les JCheckBoxMenuItems montre deux façons différentes de déterminer ce qui a été coché : la correspondance des chaînes (qui, comme mentionné ci-dessus, n'est pas une approche très sûre bien qu'on la rencontre) et la correspondance de l'objet cible de l'événement. Il montre aussi que la méthode getState() peut être utilisée pour connaître son état. On peut également changer l'état d'un JCheckBoxMenuItem à l'aide de setState().

Les événements des menus sont un peu inconsistants et peuvent prêter à confusion : les JMenuItems utilisent des ActionListeners, mais les JCheckboxMenuItems utilisent des ItemListeners. Les objets JMenu peuvent aussi supporter des ActionListeners, mais ce n'est généralement pas très utile. En général, on attache des listeners à chaque JMenuItem, JCheckBoxMenuItem, ou JRadioButtonMenuItem, mais l'exemple montre des ItemListeners et des ActionListeners attachés aux divers composants de menus.

Swing supporte les mnémoniques, ou raccourcis clavier, de sorte qu'on peut sélectionner tout ce qui est dérivé de AbstractButton (bouton, menu, élément, etc.) en utilisant le clavier à la place de la souris. C'est assez simple : pour le JMenuItem on peut utiliser le constructeur surchargé qui prend en deuxième argument l'identificateur de la touche. Cependant, la plupart des AbstractButtons n'ont pas ce constructeur ; une manière plus générale de résoudre ce problème est d'utiliser la méthode setMnemonic(). L'exemple ci-dessus ajoute une mnémonique au bouton et à certains des éléments de menus : les indicateurs de raccourcis apparaissent automatiquement sur les composants.

On peut aussi voir l'utilisation de setActionCommand(). Ceci paraît un peu bizarre, car dans chaque cas la commande d'action [action command] est exactement la même que le label sur le composant du menu. Pourquoi ne pas utiliser simplement le label plutôt que cette chaîne de remplacement ? Le problème est l'internationalisation. Si on réoriente ce programme vers une autre langue, on désire changer uniquement le label du menu, et pas le code (ce qui introduirait à coup sûr d'autres erreurs). Donc pour faciliter ceci pour les codes qui testent la chaîne associée à un composant de menu, la commande d'action peut être invariante tandis que le label du menu peut changer. Tout le code fonctionne avec la commande d'action, de sorte qu'il n'est pas touché par les modifications des labels des menus. Remarquons que dans ce programme on ne recherche pas des commandes d'actions pour tous les composants de menus, de sorte que ceux qui ne sont pas examinés n'ont pas de commande d'action positionnée.

La plus grosse partie du travail se trouve dans les listeners. BL effectue l'échange des JMenuBars. Dans ML, l'approche du "qui a sonné ?" est utilisée en utilisant la source de l'ActionEvent et en l'émettant vers un JMenuItem, en faisant passer la chaîne de la commande d'action à travers une instruction if en cascade.

Le listener FL est simple, bien qu'il gère les différents parfums du menu parfums. Cette approche est utile si la logique est simple, mais en général, on utilisera l'approche de FooL, BarL et BazL, dans lesquels ils sont chacun attachés à un seul composant de menu de sorte qu'il n'est pas nécessaire d'avoir une logique de détection supplémentaire, et on sait exactement qui a appelé le listener. Même avec la profusion de classes générées de cette façon, le code interne tend à être plus petit et le traitement est plus fiable.

On peut voir que le code d'un menu devient rapidement long et désordonné. C'est un autre cas où l'utilisation d'un GUI builder est la solution appropriée. Un bon outil gérera également la maintenance des menus.

XV-H-15. Menus pop-up

La façon la plus directe d'implémenter un JPopupMenu est de créer une classe interne qui étend MouseAdapter, puis d'ajouter un objet de cette classe interne à chaque composant pour lequel on veut créer le pop-up :

 
Sélectionnez
//: c13:Popup.java
// Création de menus popup avec Swing.
// <applet code=Popup
//&#160;&#160;width=300 height=200></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class Popup extends JApplet {
&#160;&#160;JPopupMenu popup = new JPopupMenu();
&#160;&#160;JTextField t = new JTextField(10);
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(t);
&#160;&#160;&#160;&#160;ActionListener al = new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;t.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;((JMenuItem)e.getSource()).getText());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;};
&#160;&#160;&#160;&#160;JMenuItem m = new JMenuItem("Hither");
&#160;&#160;&#160;&#160;m.addActionListener(al);
&#160;&#160;&#160;&#160;popup.add(m);
&#160;&#160;&#160;&#160;m = new JMenuItem("Yon");
&#160;&#160;&#160;&#160;m.addActionListener(al);
&#160;&#160;&#160;&#160;popup.add(m);
&#160;&#160;&#160;&#160;m = new JMenuItem("Afar");
&#160;&#160;&#160;&#160;m.addActionListener(al);
&#160;&#160;&#160;&#160;popup.add(m);
&#160;&#160;&#160;&#160;popup.addSeparator();
&#160;&#160;&#160;&#160;m = new JMenuItem("Stay Here");
&#160;&#160;&#160;&#160;m.addActionListener(al);
&#160;&#160;&#160;&#160;popup.add(m);
&#160;&#160;&#160;&#160;PopupListener pl = new PopupListener();
&#160;&#160;&#160;&#160;addMouseListener(pl);
&#160;&#160;&#160;&#160;t.addMouseListener(pl);
&#160;&#160;}
&#160;&#160;class PopupListener extends MouseAdapter {
&#160;&#160;&#160;&#160;public void mousePressed(MouseEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;maybeShowPopup(e);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;public void mouseReleased(MouseEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;maybeShowPopup(e);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;private void maybeShowPopup(MouseEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;if(e.isPopupTrigger()) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;popup.show(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;e.getComponent(), e.getX(), e.getY());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new Popup(), 300, 200);
&#160;&#160;}
} ///:~

Le même ActionListener est ajouté à chaque JMenuItem de façon à prendre le texte du label du menu et l'insérer dans le JTextField.

XV-H-16. Dessiner

Dans un bon outil de GUI, dessiner devrait être assez facile, et ça l'est dans la bibliothèque Swing. Le problème de tout exemple de dessin est que les calculs qui déterminent où vont les éléments sont souvent beaucoup plus compliqués que les appels aux sous-programmes de dessin, et que ces calculs sont souvent mélangés aux appels de dessin, de sorte que l'interface semble plus compliquée qu'elle ne l'est.

Pour simplifier, considérons le problème de la représentation de données sur l'écran. Ici, les données sont fournies par la méthode intrinsèque Math.sin() qui est la fonction mathématique sinus. Pour rendre les choses un peu plus intéressantes, et pour mieux montrer combien il est facile d'utiliser les composants Swing, un curseur sera placé en bas du formulaire pour contrôler dynamiquement le nombre de cycles du sinus affiché. De plus, si on redimensionne la fenêtre, on verra le sinus s'adapter de lui-même à la nouvelle taille de la fenêtre.

Dans l'exemple suivant, toute l'intelligence concernant le dessin est contenue dans la classe SineDraw; la classe SineWave configure simplement le programme et le curseur. Dans SineDraw, la méthode setCycles() fournit un moyen pour permettre à un autre objet (le curseur dans ce cas) de contrôler le nombre de cycles.

 
Sélectionnez
//: c13:SineWave.java
// Dessin avec Swing, en utilisant un JSlider.
// <applet code=SineWave
//&#160;&#160;width=700 height=400></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

class SineDraw extends JPanel {
&#160;&#160;static final int SCALEFACTOR = 200;
&#160;&#160;int cycles;
&#160;&#160;int points;
&#160;&#160;double[] sines;
&#160;&#160;int[] pts;
&#160;&#160;SineDraw() { setCycles(5); }
&#160;&#160;public void setCycles(int newCycles) {
&#160;&#160;&#160;&#160;cycles = newCycles;
&#160;&#160;&#160;&#160;points = SCALEFACTOR * cycles * 2;
&#160;&#160;&#160;&#160;sines = new double[points];
&#160;&#160;&#160;&#160;pts = new int[points];
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;double radians = (Math.PI/SCALEFACTOR) * i;
&#160;&#160;&#160;&#160;&#160;&#160;sines[i] = Math.sin(radians);
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;repaint();
&#160;&#160;}&#160;&#160;&#160;&#160;
&#160;&#160;public void paintComponent(Graphics g) {
&#160;&#160;&#160;&#160;super.paintComponent(g);
&#160;&#160;&#160;&#160;int maxWidth = getWidth();
&#160;&#160;&#160;&#160;double hstep = (double)maxWidth/(double)points;
&#160;&#160;&#160;&#160;int maxHeight = getHeight();
&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;pts[i] = (int)(sines[i] * maxHeight/2 * .95
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; + maxHeight/2);
&#160;&#160;&#160;&#160;g.setColor(Color.red);
&#160;&#160;&#160;&#160;for(int i = 1; i &#160;&#160;&#160;&#160;&#160;&#160;int x1 = (int)((i - 1) * hstep);
&#160;&#160;&#160;&#160;&#160;&#160;int x2 = (int)(i * hstep);
&#160;&#160;&#160;&#160;&#160;&#160;int y1 = pts[i-1];
&#160;&#160;&#160;&#160;&#160;&#160;int y2 = pts[i];
&#160;&#160;&#160;&#160;&#160;&#160;g.drawLine(x1, y1, x2, y2);
&#160;&#160;&#160;&#160;}
&#160;&#160;}
}

public class SineWave extends JApplet {
&#160;&#160;SineDraw sines = new SineDraw();
&#160;&#160;JSlider cycles = new JSlider(1, 30, 5);
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(sines);
&#160;&#160;&#160;&#160;cycles.addChangeListener(new ChangeListener(){
&#160;&#160;&#160;&#160;&#160;&#160;public void stateChanged(ChangeEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;sines.setCycles(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;((JSlider)e.getSource()).getValue());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;cp.add(BorderLayout.SOUTH, cycles);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new SineWave(), 700, 400);
&#160;&#160;}
} ///:~

Tous les membres de données et tableaux sont utilisés dans le calcul des points du sinus : cycles indique le nombre de périodes complètes de sinus désiré, points contient le nombre total de points qui seront tracés, sines contient les valeurs de la fonction sinus, et pts contient les coordonnées y des points qui seront tracés sur le JPanel. La méthode setCycles() construit le tableau selon le nombre de points nécessaires et remplit le tableau sines de valeurs. En appelant repaint(), setCycles force l'appel de paintComponent() , afin que le reste des calculs et le dessin aient lieu.

La première chose à faire lorsqu'on redéfinit paintComponent() est d'appeler la version de base de la méthode. Ensuite on peut faire ce que l'on veut ; normalement cela signifie utiliser les méthodes de Graphics qu'on peut trouver dans la documentation de java.awt.Graphics (dans la documentation HTML de java.sun.com) pour dessiner et peindre des pixels sur le JPanel. On peut voir ici que la plupart du code concerne l'exécution des calculs, les deux seules méthodes qui manipulent effectivement l'écran sont setColor() et drawLine(). Vous aurez probablement la même sensation lorsque vous créerez votre propre programme d'affichage de données graphiques : vous passerez la plus grande partie du temps à déterminer ce qu'il faut dessiner, mais le dessin en lui-même sera assez simple.

Lorsque j'ai créé ce programme, j'ai passé le plus gros de mon temps à obtenir la courbe du sinus à afficher. Ceci fait, j'ai pensé que ce serait bien de pouvoir modifier dynamiquement le nombre de cycles. Mes expériences de programmation de ce genre de choses dans d'autres langages me rendaient un peu réticent, mais cette partie se révéla la partie la plus facile du projet. J'ai créé un JSlider (les arguments sont respectivement la valeur de gauche du JSlider, la valeur de droite, et la valeur initiale, mais il existe d'autres constructeurs) et je l'ai déposé dans le JApplet. Ensuite j'ai regardé dans la documentation HTML et j'ai vu que le seul listener était le addChangeListener, qui était déclenché chaque fois que le curseur était déplacé suffisamment pour produire une nouvelle valeur. La seule méthode pour cela était évidemment appelée stateChanged(), qui fournit un objet ChangeEvent, de manière à pouvoir rechercher la source de la modification et obtenir la nouvelle valeur. En appelant setCycles() des objets sines, la nouvelle valeur est prise en compte et le JPanel est redessiné.

En général, on verra que la plupart des problèmes Swing peuvent être résolus en suivant un processus semblable, et on verra qu'il est en général assez simple, même si on n'a pas utilisé auparavant un composant donné.

Si le problème est plus compliqué, il y a d'autres solutions plus sophistiquées, par exemple les composants JavaBeans de fournisseurs tiers, et l'API Java 2D. Ces solutions sortent du cadre de ce livre, mais vous devriez les prendre en considération si votre code de dessin devient trop coûteux.

XV-H-17. Boîtes de dialogue

Une boîte de dialogue est une fenêtre qui est issue d'une autre fenêtre. Son but est de traiter un problème spécifique sans encombrer la fenêtre d'origine avec ces détails. Les boîtes de dialogue sont fortement utilisées dans les environnements de programmation à fenêtres, mais moins fréquemment utilisées dans les applets.

Pour créer une boîte de dialogue, il faut hériter de JDialog, qui est simplement une sorte de Window, comme les JFrames. Un JDialog possède un layout manager (qui est par défaut le BorderLayout) auquel on ajoute des listeners d'événements pour traiter ceux-ci. Il y a une différence importante : on ne veut pas fermer l'application lors de l'appel de windowClosing(). Au lieu de cela, on libère les ressources utilisées par la fenêtre de dialogue en appelant dispose(). Voici un exemple très simple :

 
Sélectionnez
//: c13:Dialogs.java
// Création et utilisation de boîtes de dialogue.
// <applet code=Dialogs width=125 height=75>
// </applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;

class MyDialog extends JDialog {
&#160;&#160;public MyDialog(JFrame parent) {
&#160;&#160;&#160;&#160;super(parent, "My dialog", true);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.setLayout(new FlowLayout());
&#160;&#160;&#160;&#160;cp.add(new JLabel("Here is my dialog"));
&#160;&#160;&#160;&#160;JButton ok = new JButton("OK");
&#160;&#160;&#160;&#160;ok.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dispose(); // Ferme le dialogue
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;cp.add(ok);
&#160;&#160;&#160;&#160;setSize(150,125);
&#160;&#160;}
}

public class Dialogs extends JApplet {
&#160;&#160;JButton b1 = new JButton("Dialog Box");
&#160;&#160;MyDialog dlg = new MyDialog(null);
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;b1.addActionListener(new ActionListener() {
&#160;&#160;&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dlg.show();
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;});
&#160;&#160;&#160;&#160;getContentPane().add(b1);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new Dialogs(), 125, 75);
&#160;&#160;}
} ///:~

Une fois le JDialog créé, la méthode show() doit être appelée pour l'afficher et l'activer. Pour que le dialogue se ferme, il faut appeler dispose().

On remarquera que tout ce qui sort d'une applet, y compris les boîtes de dialogue, n'est pas digne de confiance. C'est-à-dire qu'on obtient un avertissement dans la fenêtre qui apparaît. Ceci est dû au fait qu'en théorie il serait possible de tromper l'utilisateur et lui faire croire qu'il a à faire avec une de ses applications normales et de le faire taper son numéro de carte de crédit, qui partirait alors sur le Web. Une applet est toujours attachée à une page Web et visible dans un navigateur, tandis qu'une boîte de dialogue est détachée, et tout ceci est donc possible en théorie. Le résultat est qu'il n'est pas fréquent de voir une applet qui utilise une boîte de dialogue.

L'exemple suivant est plus complexe; la boîte de dialogue est composée d'une grille (en utilisant GridLayout) d'un type de bouton particulier qui est défini ici comme la classe ToeButton. Ce bouton dessine un cadre autour de lui et, selon son état, un blanc, un x ou un o au milieu. Il démarre en blanc, et ensuite, selon à qui c'est le tour, se modifie en x ou en o. Cependant, il transformera le x en o et vice versa lorsqu'on clique sur le bouton (ceci rend le principe du tic-tac-toe seulement un peu plus ennuyeux qu'il ne l'est déjà). De plus, la boîte de dialogue peut être définie avec un nombre quelconque de rangées et de colonnes dans la fenêtre principale de l'application.

 
Sélectionnez
//: c13:TicTacToe.java
// Démonstration de boîtes de dialogue
// et création de vos propres composants.
// <applet code=TicTacToe
//&#160;&#160;width=200 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class TicTacToe extends JApplet {
&#160;&#160;JTextField 
&#160;&#160;&#160;&#160;rows = new JTextField("3"),
&#160;&#160;&#160;&#160;cols = new JTextField("3");
&#160;&#160;static final int BLANK = 0, XX = 1, OO = 2;
&#160;&#160;class ToeDialog extends JDialog {
&#160;&#160;&#160;&#160;int turn = XX; // Démarre avec x a jouer
&#160;&#160;&#160;&#160;// w = nombre de cellules en largeur
&#160;&#160;&#160;&#160;// h = nombre de cellules en hauteur
&#160;&#160;&#160;&#160;public ToeDialog(int w, int h) {
&#160;&#160;&#160;&#160;&#160;&#160;setTitle("The game itself");
&#160;&#160;&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;&#160;&#160;cp.setLayout(new GridLayout(w, h));
&#160;&#160;&#160;&#160;&#160;&#160;for(int i = 0; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;cp.add(new ToeButton());
&#160;&#160;&#160;&#160;&#160;&#160;setSize(w * 50, h * 50);
&#160;&#160;&#160;&#160;&#160;&#160;// fermeture du dialogue en JDK 1.3 :
&#160;&#160;&#160;&#160;&#160;&#160;//#setDefaultCloseOperation(
&#160;&#160;&#160;&#160;&#160;&#160;//#&#160;&#160;DISPOSE_ON_CLOSE);
&#160;&#160;&#160;&#160;&#160;&#160;// fermeture du dialogue en JDK 1.2 :
&#160;&#160;&#160;&#160;&#160;&#160;addWindowListener(new WindowAdapter() {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;public void windowClosing(WindowEvent e){
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dispose();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;});&#160;&#160;&#160;&#160;
&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;class ToeButton extends JPanel {
&#160;&#160;&#160;&#160;&#160;&#160;int state = BLANK;
&#160;&#160;&#160;&#160;&#160;&#160;public ToeButton() {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;addMouseListener(new ML());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;public void paintComponent(Graphics g) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;super.paintComponent(g);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int x1 = 0;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int y1 = 0;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int x2 = getSize().width - 1;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int y2 = getSize().height - 1;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;g.drawRect(x1, y1, x2, y2);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;x1 = x2/4;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;y1 = y2/4;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int wide = x2/2;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;int high = y2/2;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(state == XX) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;g.drawLine(x1, y1, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;x1 + wide, y1 + high);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;g.drawLine(x1, y1 + high, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;x1 + wide, y1);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(state == OO) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;g.drawOval(x1, y1, 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;x1 + wide/2, y1 + high/2);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;class ML extends MouseAdapter {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;public void mousePressed(MouseEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;if(state == BLANK) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;state = turn;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;turn = (turn == XX ? OO : XX);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;} 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;else
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;state = (state == XX ? OO : XX);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;repaint();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class BL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JDialog d = new ToeDialog(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Integer.parseInt(rows.getText()),
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;Integer.parseInt(cols.getText()));
&#160;&#160;&#160;&#160;&#160;&#160;d.setVisible(true);
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;public void init() {
&#160;&#160;&#160;&#160;JPanel p = new JPanel();
&#160;&#160;&#160;&#160;p.setLayout(new GridLayout(2,2));
&#160;&#160;&#160;&#160;p.add(new JLabel("Rows", JLabel.CENTER));
&#160;&#160;&#160;&#160;p.add(rows);
&#160;&#160;&#160;&#160;p.add(new JLabel("Columns", JLabel.CENTER));
&#160;&#160;&#160;&#160;p.add(cols);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(p, BorderLayout.NORTH);
&#160;&#160;&#160;&#160;JButton b = new JButton("go");
&#160;&#160;&#160;&#160;b.addActionListener(new BL());
&#160;&#160;&#160;&#160;cp.add(b, BorderLayout.SOUTH);
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new TicTacToe(), 200, 100);
&#160;&#160;}
} ///:~

Comme les statics peuvent être uniquement au niveau le plus extérieur de la classe, les classes internes ne peuvent pas avoir de données static ni de classes internes static.

La méthode paintComponent() dessine le carré autour du panneau, et le x ou le o. C'est rempli de calculs fastidieux, mais c'est direct.

Les clics de souris sont capturés par le MouseListener, qui vérifie d'abord si le panneau a déjà quelque chose d'écrit sur lui. Si ce n'est pas le cas, on recherche la fenêtre parente pour déterminer à qui est le tour, et on positionne l'état du ToeButton en conséquence. Le ToeButton retrouve le parent par le mécanisme de la classe interne, et passe au tour suivant. Si le bouton affiche déjà un x ou un o, son affichage est inversé. On peut voir dans ces calculs l'usage pratique du if-else ternaire décrit au titre V. On repeint le ToeButton chaque fois qu'il change d'état.

Le constructeur de ToeDialog est assez simple : il ajoute à un GridLayout autant de boutons que demandé, puis redimensionne chaque bouton à 50 pixels.

TicTacToe installe l'ensemble de l'application par la création de JTextFields (pour entrer le nombre de rangées et colonnes de la grille de boutons) et le bouton « go » avec son ActionListener. Lorsqu'on appuie sur le bouton, les données dans les JTextFields doivent être récupérées et, puisqu'elles sont au format String, transformées en ints en utilisant la méthode statique Integer.parseInt().

XV-H-18. Dialogues pour les fichiers [File dialogs]

Certains systèmes d'exploitation ont des boîtes de dialogue standard pour gérer certaines choses telles que les fontes, les couleurs, les imprimantes, etc. En tout cas, pratiquement tous les systèmes d'exploitation graphiques fournissent les moyens d'ouvrir et de sauver les fichiers, et le JFileChooser de Java les encapsule pour une utilisation facile.

L'application suivante utilise deux sortes de dialogues JFileChooser, un pour l'ouverture et un pour la sauvegarde. La plupart du code devrait maintenant être familier, et toute la partie intéressante se trouve dans les action listeners pour les différents clics de boutons :

 
Sélectionnez
//: c13:FileChooserTest.java
// Démonstration de boîtes de dialogues de fichiers.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;

public class FileChooserTest extends JFrame {
&#160;&#160;JTextField 
&#160;&#160;&#160;&#160;filename = new JTextField(),
&#160;&#160;&#160;&#160;dir = new JTextField();
&#160;&#160;JButton 
&#160;&#160;&#160;&#160;open = new JButton("Open"),
&#160;&#160;&#160;&#160;save = new JButton("Save");
&#160;&#160;public FileChooserTest() {
&#160;&#160;&#160;&#160;JPanel p = new JPanel();
&#160;&#160;&#160;&#160;open.addActionListener(new OpenL());
&#160;&#160;&#160;&#160;p.add(open);
&#160;&#160;&#160;&#160;save.addActionListener(new SaveL());
&#160;&#160;&#160;&#160;p.add(save);
&#160;&#160;&#160;&#160;Container cp = getContentPane();
&#160;&#160;&#160;&#160;cp.add(p, BorderLayout.SOUTH);
&#160;&#160;&#160;&#160;dir.setEditable(false);
&#160;&#160;&#160;&#160;filename.setEditable(false);
&#160;&#160;&#160;&#160;p = new JPanel();
&#160;&#160;&#160;&#160;p.setLayout(new GridLayout(2,1));
&#160;&#160;&#160;&#160;p.add(filename);
&#160;&#160;&#160;&#160;p.add(dir);
&#160;&#160;&#160;&#160;cp.add(p, BorderLayout.NORTH);
&#160;&#160;}
&#160;&#160;class OpenL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JFileChooser c = new JFileChooser();
&#160;&#160;&#160;&#160;&#160;&#160;// Démontre le dialogue "Open" :
&#160;&#160;&#160;&#160;&#160;&#160;int rVal = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.showOpenDialog(FileChooserTest.this);
&#160;&#160;&#160;&#160;&#160;&#160;if(rVal == JFileChooser.APPROVE_OPTION) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;filename.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.getSelectedFile().getName());
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dir.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.getCurrentDirectory().toString());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;if(rVal == JFileChooser.CANCEL_OPTION) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;filename.setText("You pressed cancel");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dir.setText("");
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;class SaveL implements ActionListener {
&#160;&#160;&#160;&#160;public void actionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160;&#160;&#160;JFileChooser c = new JFileChooser();
&#160;&#160;&#160;&#160;&#160;&#160;// Démontre le dialogue "Save" :
&#160;&#160;&#160;&#160;&#160;&#160;int rVal = 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.showSaveDialog(FileChooserTest.this);
&#160;&#160;&#160;&#160;&#160;&#160;if(rVal == JFileChooser.APPROVE_OPTION) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;filename.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.getSelectedFile().getName());
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dir.setText(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;c.getCurrentDirectory().toString());
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;&#160;&#160;if(rVal == JFileChooser.CANCEL_OPTION) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;filename.setText("You pressed cancel");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;dir.setText("");
&#160;&#160;&#160;&#160;&#160;&#160;}
&#160;&#160;&#160;&#160;}
&#160;&#160;}
&#160;&#160;public static void main(String[] args) {
&#160;&#160;&#160;&#160;Console.run(new FileChooserTest(), 250, 110);
&#160;&#160;}
} ///:~

Pour un dialogue d'ouverture de fichier, on appelle showOpenDialog(), et pour un dialogue de sauvegarde de fichier, on appelle showSaveDialog(). Ces commandes ne reviennent que lorsque le dialogue est fermé. L'objet JFileChooser existe encore, de sorte qu'on peut en lire les données. Les méthodes getSelectedFile() et getCurrentDirectory() sont deux façons d'obtenir les résultats de l'opération. Si celles-ci renvoient null, cela signifie que l'utilisateur a abandonné le dialogue.

XV-H-19. HTML sur des composants Swing

Tout composant acceptant du texte peut également accepter du texte HTML, qu'il reformatera selon les règles HTML. Ceci signifie qu'on peut très facilement ajouter du texte de fantaisie à un composant Swing. Par exemple :

 
Sélectionnez
//: c13:HTMLButton.java
// Mettre du texte HTML sur des composants Swing.
// <applet code=HTMLButton width=200 height=500>
// </applet>
importjavax.swing.*;
importjava.awt.event.*;
importjava.awt.*;
importcom.bruceeckel.swing.*;

publicclassHTMLButton extendsJApplet {
JButton b = newJButton("<html><b><font size=+2>"+
&#160;&#160; "<center>Hello!<br><i>Press me now!");
publicvoidinit() {
&#160;&#160; b.addActionListener(newActionListener() {
&#160;&#160;&#160;&#160; publicvoidactionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160; getContentPane().add(newJLabel("<html>"+
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; "<i><font size=+4>Kapow!"));
&#160;&#160;&#160;&#160;&#160;&#160; // Force un réalignement pour
&#160;&#160;&#160;&#160;&#160;&#160; // inclure le nouveau label:
&#160;&#160;&#160;&#160;&#160;&#160; validate();
&#160;&#160;&#160;&#160; }
&#160;&#160; });
&#160;&#160; Container cp = getContentPane();
&#160;&#160; cp.setLayout(newFlowLayout());
&#160;&#160; cp.add(b);
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newHTMLButton(), 200, 500);
}
} ///:~

Le texte doit commencer avec, et ensuite on peut utiliser les tags HTML normaux. Remarquons que les tags de fermeture ne sont pas obligatoires.

L'ActionListener ajoute au formulaire un nouveau JLabel contenant du texte HTML. Comme ce label n'est pas ajouté dans la méthode init(), on doit appeler la méthode validate() du conteneur de façon à forcer une redisposition des composants (et de ce fait un affichage du nouveau label).

On peut également ajouter du texte HTML à un JTabbedPane, JMenuItem, JToolTip, JRadioButton ou un JCheckBox.

XV-H-20. Curseurs [sliders] et barres de progression [progress bars]

Un slider (qu'on a déjà utilisé dans l'exemple du sinus) permet à l'utilisateur de rentrer une donnée en déplaçant un point en avant ou en arrière, ce qui est intuitif dans certains cas (un contrôle de volume, par exemple). Un progress bar représente une donnée en remplissant proportionnellement un espace vide pour que l'utilisateur ait une idée de la valeur. Mon exemple favori pour ces composants consiste à simplement lier le curseur à la barre de progression, de sorte que lorsqu'on déplace le curseur la barre de progression change en conséquence :

 
Sélectionnez
//: c13:Progress.java
// Utilisation de progress bars et de sliders.
// <applet code=Progress
//&#160;&#160;width=300 height=200></applet>
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.event.*;
importjavax.swing.border.*;
importcom.bruceeckel.swing.*;

publicclassProgress extendsJApplet {
JProgressBar pb = newJProgressBar();
JSlider sb = 
&#160;&#160; newJSlider(JSlider.HORIZONTAL, 0, 100, 60);
publicvoidinit() {
&#160;&#160; Container cp = getContentPane();
&#160;&#160; cp.setLayout(newGridLayout(2,1));
&#160;&#160; cp.add(pb);
&#160;&#160; sb.setValue(0);
&#160;&#160; sb.setPaintTicks(true);
&#160;&#160; sb.setMajorTickSpacing(20);
&#160;&#160; sb.setMinorTickSpacing(5);
&#160;&#160; sb.setBorder(newTitledBorder("Slide Me"));
&#160;&#160; pb.setModel(sb.getModel()); // Partage du modèle
&#160;&#160; cp.add(sb);
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newProgress(), 300, 200);
}
} ///:~

La clé du lien entre les deux composants se trouve dans le partage de leur modèle, dans la ligne :

 
Sélectionnez
pb.setModel(sb.getModel());

Naturellement, on pourrait aussi contrôler les deux composants en utilisant un listener, mais ceci est plus direct pour les cas simples.

Le JProgressBar est assez simple, mais le JSlider a un grand nombre d'options, telles que l'orientation et les graduations mineures et majeures. Remarquons la simplicité de l'ajout d'une bordure avec titre.

XV-H-21. Arbres [Trees]

L'utilisation d'un JTree peut être aussi simple que ceci :

 
Sélectionnez
add(newJTree(
newObject[] {"this", "that", "other"}));

Ceci affiche un arbre rudimentaire. L'API pour les arbres est vaste, probablement une des plus importantes de Swing. On peut faire à peu près tout ce qu'on veut avec des arbres, mais les tâches plus complexes demandent davantage de recherches et d'expérimentations.

Heureusement, il y a un niveau intermédiaire fourni dans la bibliothèque : les composants arbres par défaut, qui font en général ce dont on a besoin, de sorte que la plupart du temps on peut se contenter de ces composants, et ce n'est que dans des cas particuliers qu'on aura besoin d'approfondir et de comprendre plus en détail les arbres.

L'exemple suivant utilise les composants arbres par défaut pour afficher un arbre dans une applet. Lorsqu'on appuie sur le bouton, un nouveau sous-arbre est ajouté sous le nœud sélectionné (si aucun nœud n'est sélectionné, le nœud racine est utilisé) :

 
Sélectionnez
//: c13:Trees.java
// Exemple d'arbre Swing simple. Les arbres peuvent
// être beaucoup plus complexes que celui-ci.
// <applet code=Trees
//&#160;&#160;width=250 height=250></applet>
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.tree.*;
importcom.bruceeckel.swing.*;

// Prend un tableau de Strings et crée un nœud à partir
// du premier élément, et des feuilles avec les autres :
classBranch {
DefaultMutableTreeNode r;
publicBranch(String[] data) {
&#160;&#160; r = newDefaultMutableTreeNode(data[0]);
&#160;&#160; for(inti = 1; i &#160;&#160;&#160;&#160; r.add(newDefaultMutableTreeNode(data[i]));
}
publicDefaultMutableTreeNode node() { 
&#160;&#160; returnr; 
}
}&#160;&#160;

publicclassTrees extendsJApplet {
String[][] data = {
&#160;&#160; { "Colors", "Red", "Blue", "Green"},
&#160;&#160; { "Flavors", "Tart", "Sweet", "Bland"},
&#160;&#160; { "Length", "Short", "Medium", "Long"},
&#160;&#160; { "Volume", "High", "Medium", "Low"},
&#160;&#160; { "Temperature", "High", "Medium", "Low"},
&#160;&#160; { "Intensity", "High", "Medium", "Low"},
};
staticinti = 0;
DefaultMutableTreeNode root, child, chosen;
JTree tree;
DefaultTreeModel model;
publicvoidinit() {
&#160;&#160; Container cp = getContentPane();
&#160;&#160; root = newDefaultMutableTreeNode("root");
&#160;&#160; tree = newJTree(root);
&#160;&#160; // On l'ajoute et on le rend scrollable :
&#160;&#160; cp.add(newJScrollPane(tree), 
&#160;&#160;&#160;&#160; BorderLayout.CENTER);
&#160;&#160; // Obtention du modèle de l'arbre :
&#160;&#160; model =(DefaultTreeModel)tree.getModel();
&#160;&#160; JButton test = newJButton("Press me");
&#160;&#160; test.addActionListener(newActionListener() {
&#160;&#160;&#160;&#160; publicvoidactionPerformed(ActionEvent e){
&#160;&#160;&#160;&#160;&#160;&#160; if(i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; child = newBranch(data[i++]).node();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // Quel est le dernier élément cliqué ?
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; chosen = (DefaultMutableTreeNode)
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; tree.getLastSelectedPathComponent();
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; if(chosen ==null) chosen = root;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // Le modèle créera l'événement approprié.
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // En réponse, l'arbre se remettra à jour :
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; model.insertNodeInto(child, chosen, 0);
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // Ceci place le nouveau nœud
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // sur le nœud actuellement sélectionné.
&#160;&#160;&#160;&#160;&#160;&#160; }
&#160;&#160;&#160;&#160; }
&#160;&#160; });
&#160;&#160; // Change les couleurs des boutons :
&#160;&#160; test.setBackground(Color.blue);
&#160;&#160; test.setForeground(Color.white);
&#160;&#160; JPanel p = newJPanel();
&#160;&#160; p.add(test);
&#160;&#160; cp.add(p, BorderLayout.SOUTH);
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newTrees(), 250, 250);
}
} ///:~

La première classe, Branch, est un outil qui prend un tableau et construit un DefaultMutableTreeNodeavec la première String comme racine, et le reste des Strings du tableau pour les feuilles. Ensuite node() peut être appelé pour créer la racine de cette branche.

La classe Trees contient un tableau de Strings à deux dimensions à partir duquel des Branches peuvent être créées, ainsi qu'un static int i pour servir d'index à travers ce tableau. L'objet DefaultMutableTreeNode contient les nœuds, mais la représentation physique à l'écran est contrôlée par le JTree et son modèle associé, le DefaultTreeModel. Notons que lorsque le JTree est ajouté à l'applet, il est encapsulé dans un JScrollPane : c'est suffisant pour permettre un scrolling automatique.

Le JTree est contrôlé par son modèle. Lorsqu'on modifie les données du modèle, celui-ci génère un événement qui force le JTree à effectuer les mises à jour nécessaires de la partie visible de la représentation de l'arbre. Dans init(), le modèle est obtenu par appel à getModel(). Lorsqu'on appuie sur le bouton, une nouvelle branche est créée. Ensuite le composant actuellement sélectionné est recherché (on utilise la racine si rien n'est sélectionné) et la méthode insertNodeInto() du modèle effectue la modification de l'arbre et provoque sa mise à jour.

Un exemple comme ci-dessus peut vous donner ce dont vous avez besoin pour utiliser un arbre. Cependant les arbres ont la possibilité de faire à peu près tout ce qui est imaginable ; chaque fois que le mot default apparaît dans l'exemple ci-dessus, on peut y substituer sa propre classe pour obtenir un comportement différent. Mais attention : la plupart de ces classes ont une interface importante, de sorte qu'on risque de passer du temps à comprendre la complexité des arbres. Cependant, on a affaire ici à une bonne conception, et les autres solutions sont en général bien moins bonnes.

XV-H-22. Tables

Comme les arbres, les tables en Swing sont vastes et puissantes. Elles sont destinées principalement à être la populaire grille d'interface avec les bases de données via la Connectivité Bases de Données Java : Java DataBase Connectivity (JDBC, présenté dans le titre XVII) et pour cela elles ont une flexibilité énorme, que l'on paie en complexité. Il y a ici suffisamment pour servir de base à un tableur complet et pourrait probablement être le sujet d'un livre complet. Cependant, il est également possible de créer une name="Index1768">JTable relativement simple si on en comprend les bases.

La JTable contrôle la façon dont les données sont affichées, tandis que le TableModel contrôle les données elles-mêmes. Donc pour créer une JTable on créera d'abord un TableModel. On peut implémenter complètement l'interface TableModel, mais il est souvent plus simple d'hériter de la classe utilitaire AbstractTableModel :

 
Sélectionnez
//: c13:Table.java
// Démonstration simple d'une JTable.
// <applet code=Table
//&#160;&#160;width=350 height=200></applet>
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.table.*;
importjavax.swing.event.*;
importcom.bruceeckel.swing.*;

publicclassTable extendsJApplet {
JTextArea txt = newJTextArea(4, 20);
// Le TableModel contrôle toutes les données :
classDataModel extendsAbstractTableModel {
&#160;&#160; Object[][] data = {
&#160;&#160;&#160;&#160; {"one", "two", "three", "four"},
&#160;&#160;&#160;&#160; {"five", "six", "seven", "eight"},
&#160;&#160;&#160;&#160; {"nine", "ten", "eleven", "twelve"},
&#160;&#160; };
&#160;&#160; // Imprime les données lorsque la table change :
&#160;&#160; classTML implementsTableModelListener {
&#160;&#160;&#160;&#160; publicvoidtableChanged(TableModelEvent e){
&#160;&#160;&#160;&#160;&#160;&#160; txt.setText(""); // Vider le texte
&#160;&#160;&#160;&#160;&#160;&#160; for(inti = 0; i &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; for(intj = 0; j &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; txt.append(data[i][j] + " ");
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; txt.append("\n");
&#160;&#160;&#160;&#160;&#160;&#160; }
&#160;&#160;&#160;&#160; }
&#160;&#160; }
&#160;&#160; publicDataModel() {
&#160;&#160;&#160;&#160; addTableModelListener(newTML());
&#160;&#160; }
&#160;&#160; publicintgetColumnCount() { 
&#160;&#160;&#160;&#160; returndata[0].length; 
&#160;&#160; }
&#160;&#160; publicintgetRowCount() { 
&#160;&#160;&#160;&#160; returndata.length;
&#160;&#160; }
&#160;&#160; publicObject getValueAt(introw, intcol) {
&#160;&#160;&#160;&#160; returndata[row][col]; 
&#160;&#160; }
&#160;&#160; publicvoid
&#160;&#160; setValueAt(Object val, introw, intcol) {
&#160;&#160;&#160;&#160; data[row][col] = val;
&#160;&#160;&#160;&#160; // Indique que le changement a eu lieu :
&#160;&#160;&#160;&#160; fireTableDataChanged();
&#160;&#160; }
&#160;&#160; publicboolean
&#160;&#160; isCellEditable(introw, intcol) { 
&#160;&#160;&#160;&#160; returntrue; 
&#160;&#160; }
}
publicvoidinit() {
&#160;&#160; Container cp = getContentPane();
&#160;&#160; JTable table = newJTable(newDataModel());
&#160;&#160; cp.add(newJScrollPane(table));
&#160;&#160; cp.add(BorderLayout.SOUTH, txt);
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newTable(), 350, 200);
}
} ///:~

DataModel contient un tableau de données, mais on pourrait aussi obtenir les données depuis une autre source telle qu'une base de données. Le constructeur ajoute un TableModelListener qui imprime le tableau chaque fois que la table est modifiée. Les autres méthodes suivent les conventions de nommage des Beans ; elles sont utilisées par la JTable lorsqu'elle veut présenter les informations contenues dans DataModel. AbstractTableModel fournit des méthodes par défaut pour setValueAt() et isCellEditable() qui interdisent les modifications de données, de sorte que ces méthodes devront être redéfinies si on veut pouvoir modifier les données.

Une fois obtenu un TableModel, il suffit de le passer au constructeur de la JTable. Tous les détails concernant l'affichage, les modifications et la mise à jour seront automatiquement gérés. Cet exemple place également la JTable dans un JScrollPane.

XV-H-23. Sélection de l'aspect de l'interface [Look & Feel]

Un des aspects très intéressants de Swing est le name="Index1770">Pluggable Look & Feel. Il permet à un programme d'émuler le look and feel de divers environnements d'exploitation. On peut même faire toutes sortes de choses comme changer le look and feel pendant l'exécution du programme. Toutefois, en général on désire soit sélectionner le look and feel toutes plateformes (qui est le Metal de Swing), soit sélectionner le look and feel du système courant, de sorte à donner l'impression que le programme Java a été créé spécifiquement pour ce système. Le code permettant de sélectionner chacun de ces comportements est assez simple, mais il faut l'exécuter avant de créer les composants visuels, car ceux-ci seront créés selon le look and feel courant et ne seront pas changés par le simple changement de look and feel au milieu du programme (ce processus est compliqué et peu banal, et nous en laisserons le développement à des livres spécifiques sur Swing).

En fait, si on veut utiliser le look and feel toutes plateformes (metal) qui est la caractéristique des programmes Swing, il n'y a rien de particulier à faire, c'est la valeur par défaut. Si au contraire on veut utiliser le look and feel de l'environnement d'exploitation courant, il suffit d'insérer le code suivant, normalement au début du main(), mais de toute façon avant d'ajouter des composants :

 
Sélectionnez
try{
UIManager.setLookAndFeel(UIManager.
&#160;&#160; getSystemLookAndFeelClassName());
} catch(Exception e) {}

Il n'y a pas besoin de faire quoi que ce soit dans la clause catch, car le UIManager se positionnera par défaut au look and feel toutes plateformes si votre tentative d'installation d'un des autres échoue. Toutefois, pour le débogage, l'exception peut être utile, de sorte qu'on peut au minimum placer une instruction d'impression dans la clause catch.

Voici un programme qui utilise un argument de ligne de commande pour sélectionner un look and feel, et montre à quoi ressemblent différents composants dans le look and feel choisi :

 
Sélectionnez
//: c13:LookAndFeel.java
// Sélection de divers looks & feels.
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjava.util.*;
importcom.bruceeckel.swing.*;

publicclassLookAndFeel extendsJFrame {
String[] choices = { 
&#160;&#160; "eeny", "meeny", "minie", "moe", "toe", "you"
};
Component[] samples = {
&#160;&#160; newJButton("JButton"),
&#160;&#160; newJTextField("JTextField"),
&#160;&#160; newJLabel("JLabel"),
&#160;&#160; newJCheckBox("JCheckBox"),
&#160;&#160; newJRadioButton("Radio"),
&#160;&#160; newJComboBox(choices),
&#160;&#160; newJList(choices),
};
publicLookAndFeel() {
&#160;&#160; super("Look And Feel");
&#160;&#160; Container cp = getContentPane();
&#160;&#160; cp.setLayout(newFlowLayout());
&#160;&#160; for(inti = 0; i &#160;&#160;&#160;&#160; cp.add(samples[i]);
}
privatestaticvoidusageError() {
&#160;&#160; System.out.println(
&#160;&#160;&#160;&#160; "Usage:LookAndFeel [cross|system|motif]");
&#160;&#160; System.exit(1);
}
publicstaticvoidmain(String[] args) {
&#160;&#160; if(args.length == 0) usageError();
&#160;&#160; if(args[0].equals("cross")) {
&#160;&#160;&#160;&#160; try{
&#160;&#160;&#160;&#160;&#160;&#160; UIManager.setLookAndFeel(UIManager.
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; getCrossPlatformLookAndFeelClassName());
&#160;&#160;&#160;&#160; } catch(Exception e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; e.printStackTrace(System.err);
&#160;&#160;&#160;&#160; }
&#160;&#160; } elseif(args[0].equals("system")) {
&#160;&#160;&#160;&#160; try{
&#160;&#160;&#160;&#160;&#160;&#160; UIManager.setLookAndFeel(UIManager.
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; getSystemLookAndFeelClassName());
&#160;&#160;&#160;&#160; } catch(Exception e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; e.printStackTrace(System.err);
&#160;&#160;&#160;&#160; }
&#160;&#160; } elseif(args[0].equals("motif")) {
&#160;&#160;&#160;&#160; try{
&#160;&#160;&#160;&#160;&#160;&#160; UIManager.setLookAndFeel("com.sun.java."+
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; "swing.plaf.motif.MotifLookAndFeel");
&#160;&#160;&#160;&#160; } catch(Exception e) {
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; e.printStackTrace(System.err);
&#160;&#160;&#160;&#160; }
&#160;&#160; } elseusageError();
&#160;&#160; // Remarquons que le look & feel doit être positionné
&#160;&#160; // avant la création des composants.
&#160;&#160; Console.run(newLookAndFeel(), 300, 200);
}
} ///:~

Il est également possible de créer un package de look and feel sur mesure, par exemple si on crée un environnement de travail pour une société qui désire une apparence spéciale. C'est un gros travail qui est bien au-delà de la portée de ce livre (en fait vous découvrirez qu'il est au-delà de la portée de beaucoup de livres dédiés à Swing).name="_Toc481064830">

XV-H-24. Le presse-papier [clipboard]

JFC permet des opérations limitées avec le presse-papier système (dans le package java.awt.datatransfer). On peut copier des objets String dans le presse-papier en tant que texte, et on peut coller du texte depuis le presse-papier dans des objets String. Bien sûr, le presse-papier est prévu pour contenir n'importe quel type de données, mais la représentation de ces données dans le presse-papier est du ressort du programme effectuant les opérations de couper et coller. L'API Java clipboard permet ces extensions à l'aide du concept de « parfum » [flavor]. Les données en provenance du presse-papier sont associées à un ensemble de flavors dans lesquels on peut les convertir (par exemple, un graphe peut être représenté par une chaîne de nombres ou par une image) et on peut vérifier si les données contenues dans le presse-papier acceptent le flavor qui nous intéresse.

Le programme suivant est une démonstration simple de couper, copier et coller des données String dans une face="Georgia">JTextArea. On remarquera que les séquences clavier utilisées normalement pour couper, copier et coller fonctionnent également. Mais si on observe un JTextField ou un JTextArea dans tout autre programme, on verra qu'ils acceptent aussi automatiquement les séquences clavier du presse-papier. Cet exemple ajoute simplement un contrôle du presse-papier par le programme, et on peut utiliser ces techniques pour capturer du texte du presse-papier depuis autre chose qu'un JTextComponent.

 
Sélectionnez
//: c13:CutAndPaste.java
// Utilisation du presse-papier.
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjava.awt.datatransfer.*;
importcom.bruceeckel.swing.*;

publicclassCutAndPaste extendsJFrame&#160;&#160;{
JMenuBar mb = newJMenuBar();
JMenu edit = newJMenu("Edit");
JMenuItem
&#160;&#160; cut = newJMenuItem("Cut"),
&#160;&#160; copy = newJMenuItem("Copy"),
&#160;&#160; paste = newJMenuItem("Paste");
JTextArea text = newJTextArea(20, 20);
Clipboard clipbd = 
&#160;&#160; getToolkit().getSystemClipboard();
publicCutAndPaste()&#160;&#160;{
&#160;&#160; cut.addActionListener(newCutL());
&#160;&#160; copy.addActionListener(newCopyL());
&#160;&#160; paste.addActionListener(newPasteL());
&#160;&#160; edit.add(cut);
&#160;&#160; edit.add(copy);
&#160;&#160; edit.add(paste);
&#160;&#160; mb.add(edit);
&#160;&#160; setJMenuBar(mb);
&#160;&#160; getContentPane().add(text);
}
classCopyL implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; String selection = text.getSelectedText();
&#160;&#160;&#160;&#160; if(selection == null)
&#160;&#160;&#160;&#160;&#160;&#160; return;
&#160;&#160;&#160;&#160; StringSelection clipString =&#160;&#160;&#160;&#160;&#160;&#160; newStringSelection(selection);
&#160;&#160;&#160;&#160; clipbd.setContents(clipString,clipString);
&#160;&#160; }
}
classCutL implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; String selection = text.getSelectedText();
&#160;&#160;&#160;&#160; if(selection == null)
&#160;&#160;&#160;&#160;&#160;&#160; return;
&#160;&#160;&#160;&#160; StringSelection clipString =&#160;&#160;&#160;&#160;&#160;&#160; newStringSelection(selection);
&#160;&#160;&#160;&#160; clipbd.setContents(clipString, clipString);
&#160;&#160;&#160;&#160; text.replaceRange("",
&#160;&#160;&#160;&#160;&#160;&#160; text.getSelectionStart(),
&#160;&#160;&#160;&#160;&#160;&#160; text.getSelectionEnd());
&#160;&#160; }
}
classPasteL implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; Transferable clipData =&#160;&#160;&#160;&#160;&#160;&#160; clipbd.getContents(CutAndPaste.this);
&#160;&#160;&#160;&#160; try{
&#160;&#160;&#160;&#160;&#160;&#160; String clipString =&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; (String)clipData.
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; getTransferData(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; DataFlavor.stringFlavor);
&#160;&#160;&#160;&#160;&#160;&#160; text.replaceRange(clipString,
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; text.getSelectionStart(),
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; text.getSelectionEnd());
&#160;&#160;&#160;&#160; } catch(Exception ex) {
&#160;&#160;&#160;&#160;&#160;&#160; System.err.println("Not String flavor");
&#160;&#160;&#160;&#160; }
&#160;&#160; }
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newCutAndPaste(), 300, 200);
}
} ///:~

La création et l'ajout du menu et du JTextArea devraient être maintenant une activité naturelle. Ce qui est différent est la création du champ Clipboard clipbd, qui est faite à l'aide du Toolkit.

Toutes les actions sont effectuées dans les listeners. Les listeners CopyL et CutL sont identiques à l'exception de la dernière ligne de CutL, qui efface la ligne qui a été copiée. Les deux lignes particulières sont la création d'un objet StringSelection à partir du String, et l'appel à setContents() avec ce StringSelection. C'est tout ce qu'il y a à faire pour mettre une String dans le presse-papier.

Dans PasteL, les données sont extraites du presse-papier à l'aide de name="Index1777">getContents(). Ce qu'il en sort est un objet Transferable assez anonyme, et on ne sait pas exactement ce qu'il contient. Un moyen de le savoir est d'appeler getTransferDataFlavors(), qui renvoie un tableau d'objets name="Index1780">DataFlavor indiquant quels flavors sont acceptés par cet objet. On peut aussi le demander directement à l'aide de isDataFlavorSupported(), en passant en paramètre le flavor qui nous intéresse. Dans ce programme, toutefois, on utilise une approche téméraire : on appelle getTransferData() en supposant que le contenu accepte le flavor String, et si ce n'est pas le cas le problème est pris en charge par le traitement d'exception.

Dans le futur, on peut s'attendre à ce qu'il y ait plus de flavors acceptés.

XV-I. Empaquetage d'une applet dans un fichier JAR

Une utilisation importante de l'utilitaire JAR est l'optimisation du chargement d'une applet. En Java 1.0, les gens avaient tendance à entasser tout leur code dans une seule classe, de sorte que le client ne devait faire qu'une seule requête au serveur pour télécharger le code de l'applet. Ceci avait pour résultat des programmes désordonnés, difficiles à lire (et à maintenir), et d'autre part le fichier .class n'était pas compressé, de sorte que le téléchargement n'était pas aussi rapide que possible.

Les fichiers JAR résolvent le problème en compressant tous les fichiers .class en un seul fichier qui est téléchargé par le navigateur. On peut maintenant avoir une conception correcte sans se préoccuper du nombre de fichiers .class qui seront nécessaires, et l'utilisateur aura un temps de téléchargement beaucoup plus court.

Prenons par exemple TicTacToe.java. Il apparaît comme une seule classe, mais en fait il contient cinq classes internes, ce qui fait six au total. Une fois le programme compilé on l'emballe dans un fichier JAR avec l'instruction :

 
Sélectionnez
jar cf TicTacToe.jar *.class

Ceci suppose que dans le répertoire courant il n'y a que les fichiers .class issus de TicTacToe.java (sinon on emporte du bagage supplémentaire).

On peut maintenant créer une page HTML avec le nouveau tag name="Index1785">archive pour indiquer le nom du fichier JAR. Voici pour exemple le tag utilisant l'ancienne forme du tag HTML :

 
Sélectionnez
<head><title>TicTacToe Example Applet
</title></head>
<body>
<applet code=TicTacToe.class
&#160;&#160;&#160;&#160;&#160;&#160; archive=TicTacToe.jar
&#160;&#160;&#160;&#160;&#160;&#160; width=200 height=100>
</applet>
</body>

Il faudra le mettre dans la nouvelle forme (confuse, compliquée) montrée plus haut dans ce chapitre pour le faire fonctionner.

XV-J. Techniques de programmation

La programmation de GUI en Java étant une technologie évolutive, avec des modifications très importantes entre Java 1.0/1.1 et la bibliothèque Swing, certains styles de programmation anciens ont pu s'insinuer dans des exemples qu'on peut trouver pour Swing. D'autre part, Swing permet une meilleure programmation que ce que permettaient les anciens modèles. Dans cette partie, certains de ces problèmes vont être montrés en présentant et en examinant certains styles de programmation.

XV-J-1. Lier des événements dynamiquement

Un des avantages du modèle d'événements Swing est sa flexibilité. On peut ajouter ou retirer un comportement sur événement à l'aide d'un simple appel de méthode. L'exemple suivant le montre :

 
Sélectionnez
//: c13:DynamicEvents.java
// On peut modifier dynamiquement le comportement sur événement.
// Montre également plusieurs actions pour un événement.
// <applet code=DynamicEvents
//&#160;&#160;width=250 height=400></applet>
importjavax.swing.*;
importjava.awt.*;
importjava.awt.event.*;
importjava.util.*;
importcom.bruceeckel.swing.*;

publicclassDynamicEvents extendsJApplet {
ArrayList v = newArrayList();
inti = 0;
JButton
&#160;&#160; b1 = newJButton("Button1",
&#160;&#160; b2 = newJButton("Button2");
JTextArea txt = newJTextArea();
classB implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; txt.append("A button was pressed\n");
&#160;&#160; }
}
classCountListener implementsActionListener {
&#160;&#160; intindex;
&#160;&#160; publicCountListener(inti) { index = i; }
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; txt.append("Counted Listener "+index+"\n");
&#160;&#160; }
}
classB1 implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; txt.append("Button 1 pressed\n");
&#160;&#160;&#160;&#160; ActionListener a = newCountListener(i++);
&#160;&#160;&#160;&#160; v.add(a);
&#160;&#160;&#160;&#160; b2.addActionListener(a);
&#160;&#160; }
}
classB2 implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; txt.append("Button2 pressed\n");
&#160;&#160;&#160;&#160; intend = v.size() - 1;
&#160;&#160;&#160;&#160; if(end >= 0) {
&#160;&#160;&#160;&#160;&#160;&#160; b2.removeActionListener(
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; (ActionListener)v.get(end));
&#160;&#160;&#160;&#160;&#160;&#160; v.remove(end);
&#160;&#160;&#160;&#160; }
&#160;&#160; }
}
publicvoidinit() {
&#160;&#160; Container cp = getContentPane();
&#160;&#160; b1.addActionListener(newB());
&#160;&#160; b1.addActionListener(newB1());
&#160;&#160; b2.addActionListener(newB());
&#160;&#160; b2.addActionListener(newB2());
&#160;&#160; JPanel p = newJPanel();
&#160;&#160; p.add(b1);
&#160;&#160; p.add(b2);
&#160;&#160; cp.add(BorderLayout.NORTH, p);
&#160;&#160; cp.add(newJScrollPane(txt));
}
publicstaticvoidmain(String[] args) {
&#160;&#160; Console.run(newDynamicEvents(), 250, 400);
}
} ///:~

Les nouvelles astuces dans cet exemple sont :

  1. Il y a plus d'un listener attaché à chaque Button. En règle générale, les composants gèrent les événements en tant que multicast, ce qui signifie qu'on peut enregistrer plusieurs listeners pour un seul événement. Pour les composants spéciaux dans lesquels un événement est géré en tant que unicast, on obtiendra une exception TooManyListenersException ;
  2. Lors de l'exécution du programme, les listeners sont ajoutés et enlevés du Button b2 dynamiquement. L'ajout est réalisé de la façon vue précédemment, mais chaque composant a aussi une méthode removeXXXListener() pour enlever chaque type de listener.

Ce genre de flexibilité permet une grande puissance de programmation.

Il faut remarquer qu'il n'est pas garanti que les listeners d'événements soient appelés dans l'ordre dans lequel ils sont ajoutés (bien que la plupart des implémentations le fassent de cette façon).

XV-J-2. Séparation entre la logique applicative [business logic] et la logique de l'interface utilisateur [UI logic]

En général on conçoit les classes de manière à ce que chacune fasse une seule chose. Ceci est particulièrement important pour le code d'une interface utilisateur, car il arrive souvent qu'on lie ce qu'on fait à la manière dont on l'affiche. Ce genre de couplage empêche la réutilisation du code. Il est de loin préférable de séparer la logique applicative de la partie GUI. De cette manière, non seulement la logique applicative est plus facile à réutiliser, mais il est également plus facile de récupérer la GUI.

Un autre problème concerne les systèmes répartis [multitiered systems], dans lesquels les objets applicatifs se trouvent sur une machine séparée. Cette centralisation des règles applicatives permet des modifications ayant un effet immédiat pour toutes les nouvelles transactions, ce qui est une façon intéressante d'installer un système. Cependant, ces objets applicatifs peuvent être utilisés dans de nombreuses applications, et de ce fait ils ne devraient pas être liés à un mode d'affichage particulier. Ils devraient se contenter d'effectuer les opérations applicatives, et rien de plus.

L'exemple suivant montre comme il est facile de séparer la logique applicative du code GUI :

 
Sélectionnez
//: c13:Separation.java
// Séparation entre la logique GUI et les objets applicatifs.
// <applet code=Separation
// width=250 height=150> </applet>
importjavax.swing.*;
importjava.awt.*;
importjavax.swing.event.*;
importjava.awt.event.*;
importjava.applet.*;
importcom.bruceeckel.swing.*;

classBusinessLogic {
privateintmodifier;
publicBusinessLogic(intmod) {
&#160;&#160; modifier = mod;
}
publicvoidsetModifier(intmod) {
&#160;&#160; modifier = mod;
}
publicintgetModifier() {
&#160;&#160; returnmodifier;
}
// Quelques opérations applicatives :
publicintcalculation1(intarg) {
&#160;&#160; returnarg * modifier;
}
publicintcalculation2(intarg) {
&#160;&#160; returnarg + modifier;
}
}

publicclassSeparation extendsJApplet {
JTextField 
&#160;&#160; t = newJTextField(15),
&#160;&#160; mod = newJTextField(15);
BusinessLogic bl = newBusinessLogic(2);
JButton
&#160;&#160; calc1 = newJButton("Calculation 1",
&#160;&#160; calc2 = newJButton("Calculation 2");
staticintgetValue(JTextField tf) {
&#160;&#160; try{
&#160;&#160;&#160;&#160; returnInteger.parseInt(tf.getText());
&#160;&#160; } catch(NumberFormatException e) {
&#160;&#160;&#160;&#160; return0;
&#160;&#160; }
}
classCalc1L implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; t.setText(Integer.toString(
&#160;&#160;&#160;&#160;&#160;&#160; bl.calculation1(getValue(t))));
&#160;&#160; }
}
classCalc2L implementsActionListener {
&#160;&#160; publicvoidactionPerformed(ActionEvent e) {
&#160;&#160;&#160;&#160; t.setText(Integer.toString(
&#160;&#160;&#160;&#160;&#160;&#160; bl.calculation2(