 |
|
13) Création de fenêtres & d'Applets |
|
|
|
|
| Texte original |
|
Traducteur :
P. Boite |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
In this book, this form will be used for
easy testing of applets. Shortly, you’ll see another coding approach which
will allow you to execute applets from the command line without the
Appletviewer.
|
|
Dans ce livre, cette forme sera utilisée pour un test facile des applets.
On verra bientôt une autre méthode de codage qui permettra d'exécuter des applets depuis la ligne
de commande sans l'Appletviewer.
|
|
|
|
Testing applets
|
|
Tester les applets
|
|
|
|
|
You can perform a simple test without any
network connection by starting up your Web browser and opening the HTML file
containing the applet tag. As the HTML file is loaded, the browser will discover
the applet tag and go hunt for the .class file specified by the
code value. Of course, it looks at the CLASSPATH to find out where to
hunt, and if your .class file isn’t in the CLASSPATH then it will
give an error message on the status line of the browser to the effect that it
couldn’t find that .class file.
|
|
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 status pour signaler qu'il n'a pas pu
trouver le fichier .class.
|
|
|
|
|
When you want to try this out on your Web
site things are a little more complicated. First of all, you must have a
Web site, which for most people means a third-party
Internet Service Provider (ISP)
at a remote location. Since the applet is just a file or set of files, the ISP
does not have to provide any special support for Java. You must also have a way
to move the HTML files and the .class files from your site to the correct
directory on the ISP machine. This is typically done with a
File Transfer Protocol (FTP)
program, of which there are many different types available for free or as
shareware. So it would seem that all you need to do is move the files to the ISP
machine with FTP, then connect to the site and HTML file using your browser; if
the applet comes up and works, then everything checks out,
right?
|
|
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 ?
|
|
|
|
|
Here’s where you can get fooled. If
the browser on the client machine cannot locate the .class file on the
server, it will hunt through the
CLASSPATH on your local
machine. Thus, the applet might not be loading properly from the server, but to
you it looks fine during your testing process because the browser finds it on
your machine. When someone else connects, however, his or her browser
can’t find it. So when you’re testing, make sure you erase the
relevant .class files (or .jar file) on your local machine to
verify that they exist in the proper location on the server.
|
|
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.
|
|
|
|
One of the most insidious places where
this happened to me is when I innocently placed an applet inside a
package. After uploading the HTML file and applet, it turned out that the
server path to the applet was confused because of the package name. However, my
browser found it in the local CLASSPATH. So I was the only one who could
properly load the applet. It took some time to discover that the package
statement was the culprit. In general, you’ll want to leave the
package statement out of
an applet.
|
|
Un des cas les plus insidieux qui me soit 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.
|
|
|
|
Running applets from the command
line
|
|
Exécuter des applets depuis la ligne de commande
|
|
|
|
|
There are times when you’d like to
make a windowed program do something else other than sit on a Web page. Perhaps
you’d also like it to do some of the things a “regular”
application can do but still have the vaunted instant portability provided by
Java. In previous chapters in this book we’ve made command-line
applications, but in some operating environments (the Macintosh, for example)
there isn’t a command line. So for any number of reasons you’d like
to build a windowed, non-applet program using Java. This is certainly a
reasonable desire.
|
|
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.
|
|
|
|
|
The Swing library allows you to make an
application that preserves the look and feel of the underlying operating
environment. If you want to build windowed applications, it makes sense to do
so[65] only if you
can use the latest version of Java and associated tools so you can deliver
applications that won’t confound your users. If for some reason
you’re forced to use an older version of Java, think hard before
committing to building a significant windowed application.
|
|
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 [65] 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.
|
|
|
|
|
Often
you’ll want to be able to create a class that can be invoked as either a
window or an applet. This is especially convenient when you’re testing the
applets, since it’s typically much faster and easier to run the resulting
applet-application from the command line than it is to start up a Web browser or
the Appletviewer.
|
|
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.
|
|
|
|
|
To create an applet that can be run from
the console command line, you simply add a main( ) to your applet
that builds an instance of the applet inside a
JFrame.[66]
As a simple example, let’s look at Applet1b.java modified to work
as both an application and an applet:
|
|
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 [66]. En tant
qu'exemple simple, observons Applet1b.java modifié pour fonctionner aussi bien en
tant qu'application qu'en tant qu'applet :
|
|
|
|
|
//: c13:Applet1c.java
// An application and an applet.
// <applet code=Applet1c width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
public class Applet1c extends JApplet {
public void init() {
getContentPane().add(new JLabel("Applet!"));
}
// A main() for the application:
public static void main(String[] args) {
JApplet applet = new Applet1c();
JFrame frame = new JFrame("Applet1c");
// To close the application:
Console.setupClosing(frame);
frame.getContentPane().add(applet);
frame.setSize(100,50);
applet.init();
applet.start();
frame.setVisible(true);
}
} ///:~
|
|
//: 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 {
public void init() {
getContentPane().add(new JLabel("Applet!"));
}
// Un main() pour l'application :
public static void main(String[] args) {
JApplet applet = new Applet1c();
JFrame frame = new JFrame("Applet1c");
// Pour fermer l'application :
Console.setupClosing(frame);
frame.getContentPane().add(applet);
frame.setSize(100,50);
applet.init();
applet.start();
frame.setVisible(true);
}
} ///:~
|
|
|
|
|
main( ) is the only element
added to the applet, and the rest of the applet is untouched. The applet is
created and added to a JFrame so that it can be displayed.
|
|
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.
|
|
|
|
|
The line:
|
|
La ligne :
|
|
|
|
|
Console.setupClosing(frame);
|
|
Console.setupClosing(frame);
|
|
|
|
|
Causes the window to be properly closed.
Console comes from com.bruceeckel.swing and will be explained a
little later.
|
|
permet la fermeture propre de la fenêtre. Console vient de
com.bruceeckel.swing et sera expliqué un peu plus tard.
|
|
|
|
You can see that in main( ),
the applet is explicitly initialized and started since in this case the browser
isn’t available to do it for you. Of course, this doesn’t provide
the full behavior of the browser, which also calls stop( ) and
destroy( ), but for most situations it’s acceptable. If
it’s a problem, you can force the calls
yourself.[67]
|
|
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">[67].
|
|
|
|
|
Notice the last line:
|
|
Notez la dernière ligne :
|
|
|
|
|
frame.setVisible(true);
|
|
frame.setVisible(true);
|
|
|
|
Without this, you won’t see
anything on the screen.
|
|
Sans elle, on ne verrait rien à l'écran.
|
|
|
|
A display framework
|
|
Un squelette d'affichage
|
|
|
|
|
Although the code that turns programs
into both applets and applications produces valuable results, if used everywhere
it becomes distracting and wastes paper. Instead, the following display
framework will be used for the Swing examples in the rest of this
book:
|
|
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 :
|
|
|
|
|
//: com:bruceeckel:swing:Console.java
// Tool for running Swing demos from the
// console, both applets and JFrames.
package com.bruceeckel.swing;
import javax.swing.*;
import java.awt.event.*;
public class Console {
// Create a title string from the class name:
public static String title(Object o) {
String t = o.getClass().toString();
// Remove the word "class":
if(t.indexOf("class") != -1)
t = t.substring(6);
return t;
}
public static void setupClosing(JFrame frame) {
// The JDK 1.2 Solution as an
// anonymous inner class:
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// The improved solution in JDK 1.3:
// frame.setDefaultCloseOperation(
// EXIT_ON_CLOSE);
}
public static void
run(JFrame frame, int width, int height) {
setupClosing(frame);
frame.setSize(width, height);
frame.setVisible(true);
}
public static void
run(JApplet applet, int width, int height) {
JFrame frame = new JFrame(title(applet));
setupClosing(frame);
frame.getContentPane().add(applet);
frame.setSize(width, height);
applet.init();
applet.start();
frame.setVisible(true);
}
public static void
run(JPanel panel, int width, int height) {
JFrame frame = new JFrame(title(panel));
setupClosing(frame);
frame.getContentPane().add(panel);
frame.setSize(width, height);
frame.setVisible(true);
}
} ///:~
|
|
//: 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 {
// Crée une chaîne de titre à partir du nom de la classe :
public static String title(Object o) {
String t = o.getClass().toString();
// Enlever le mot "class":
if(t.indexOf("class") != -1)
t = t.substring(6);
return t;
}
public static void setupClosing(JFrame frame) {
// La solution JDK 1.2 Solution avec une
// classe interne anonyme :
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// La solution amelioree en JDK 1.3 :
// frame.setDefaultCloseOperation(
// EXIT_ON_CLOSE);
}
public static void
run(JFrame frame, int width, int height) {
setupClosing(frame);
frame.setSize(width, height);
frame.setVisible(true);
}
public static void
run(JApplet applet, int width, int height) {
JFrame frame = new JFrame(title(applet));
setupClosing(frame);
frame.getContentPane().add(applet);
frame.setSize(width, height);
applet.init();
applet.start();
frame.setVisible(true);
}
public static void
run(JPanel panel, int width, int height) {
JFrame frame = new >JFrame(title(panel));
setupClosing(frame);
frame.getContentPane().add(panel);
frame.setSize(width, height);
frame.setVisible(true);
}
} ///:~
|
|
|
|
|
This is a tool you may want to use
yourself, so it’s placed in the library
com.bruceeckel.swing. The Console class
consists entirely of static methods. The first is used to extract the
class name (using RTTI) from any object and to remove the word
“class,” which is typically prepended by getClass( ).
This uses the String methods indexOf( ) to determine whether
the word “class” is there, and substring( ) to produce
the new string without “class” or the trailing space. This name is
used to label the window that is displayed by the run( )
methods.
|
|
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( ) is used to
hide the code that causes a JFrame to exit a program when that
JFrame is closed. The default behavior is to do nothing, so if you
don’t call setupClosing( ) or write the equivalent code for
your JFrame, the application won’t close.
The reason this code is hidden rather than placing it directly in the subsequent
run( ) methods is partly because it allows you to use the method by
itself when what you want to do is more complicated than what run( )
provides. However, it also isolates a change factor: Java 2 has two ways of
causing certain types of windows to close. In JDK 1.2, the solution is to create
a new WindowAdapter class and implement
windowClosing( ), as seen above (the meaning
of this will be fully explained later in this chapter). However, during the
creation of JDK 1.3 the library designers observed that you typically need to
close windows whenever you’re creating a non-applet, and so they added the
setDefaultCloseOperation( ) to JFrame
and JDialog. From the standpoint of writing code, the new method is much
nicer to use but this book was written while there was still no JDK 1.3
implemented on Linux and other platforms, so in the interest of cross-version
portability the change was isolated inside
setupClosing( ).
|
|
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 passetupClosing() ou un code équivalent pour le
JFrame, l'application ne se ferme pas. Une des raisons pour laquelle 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 WindowAdapteret d'implémenter
windowClosing(), comme vu plus haut (la signification de ceci sera expliquée
en détails plus tard dans ce chapitre). Cependant lors de la création du JDK 1.3, les concepteurs
de la librairie 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().
|
|
|
|
|
The run( ) method is
overloaded to work with JApplets, JPanels, and JFrames.
Note that only if it’s a JApplet are init( ) and
start( ) called.
|
|
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.
|
|
|
|
|
Now any applet can be run from the
console by creating a main( ) containing a line like
this:
|
|
Maintenant toute applet peut être lancée de la console en créant un
main() contenant une ligne comme celle-ci :
|
|
|
|
|
Console.run(new MyClass(), 500, 300);
|
|
Console.run(new MyClass(), 500, 300);
|
|
|
|
|
in which the last two arguments are the
display width and height. Here’s Applet1c.java modified to use
Console:
|
|
dans laquelle les deux derniers arguments sont la largeur et la hauteur de
l'affichage. Voici Applet1c.java modifié pour utiliser Console
:
|
|
|
|
|
//: c13:Applet1d.java
// Console runs applets from the command line.
// <applet code=Applet1d width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
public class Applet1d extends JApplet {
public void init() {
getContentPane().add(new JLabel("Applet!"));
}
public static void main(String[] args) {
Console.run(new Applet1d(), 100, 50);
}
} ///:~
|
|
//: 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 {
public void init() {
getContentPane().add(new JLabel("Applet!"));
}
public static void main(String[] args) {
Console.run(new Applet1d(), 100, 50);
}
} ///:~
|
|
|
|
This allows the elimination of repeated
code while providing the greatest flexibility in running the
examples.
|
|
Ceci permet l'élimination de code répétitif tout en fournissant la plus
grande flexibilité pour lancer les exemples.
|
|
|
|
Using the Windows Explorer
|
|
Utilisation de l'Explorateur Windows
|
|
|
|
|
If you’re using Windows, you can
simplify the process of running a command-line Java program by configuring the
Windows Explorer—the file
browser in Windows, not the Internet Explorer—so that you can
simply double-click on a .class file to execute it. There are several
steps in this process.
|
|
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.
|
|
|
|
|
First, download and install the
Perl programming language from www.Perl.org.
You’ll find the instructions and language documentation on that
site.
|
|
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.
|
|
|
|
|
Next, create the following script without
the first and last lines (this script is part of this book’s source-code
package):
|
|
Ensuite, créez le script suivant sans la première et la dernière lignes (ce
script fait partie du package de sources de ce livre) :
|
|
|
|
|
//:! 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/(.*\\)*(.*)/$+/;
´java $file´;
__END__
:endofperl
///:~
|
|
//:! 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/(.*\\)*(.*)/$+/;
´java $file´;
__END__
:endofperl
///:~
|
|
|
|
|
Now, open the Windows Explorer, select
“View,” “Folder Options,” then click on the “File
Types” tab. Press the “New Type” button. For
“Description of Type” enter “Java class file.” For
“Associated Extension,” enter “class.” Under
“Actions” press the “New” button. For
“Action” enter “Open,” and for “Application used
to perform action” enter a line like this:
|
|
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 :
|
|
|
|
|
"c:\aaa\Perl\RunJava.bat" "%L"
|
|
"c:\aaa\Perl\RunJava.bat" "%L"
|
|
|
|
|
You must customize the path before
“RunJava.bat” to conform to the location where you placed the batch
file.
|
|
en personnalisant le chemin devant RunJava.bat en fonction de l'endroit où
vous avez placé le fichier batch.
|
|
|
|
Once you perform this installation, you
may run any Java program by simply double-clicking on the .class file
containing a
main( ).
|
|
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().
|
|
|
|
Making a button
|
|
Création d'un bouton
|
|
|
|
|
Making a button is quite simple: you just
call the JButton constructor with the label you want on the button.
You’ll see later that you can do fancier things, like putting graphic
images on buttons.
|
|
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 par exemple y mettre des images
graphiques.
|
|
|
|
|
Usually you’ll want to create a
field for the button inside your class so that you can refer to it
later.
|
|
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.
|
|
|
|
|
The JButton is a
component—its own little window—that will automatically get
repainted as part of an update. This means that you don’t explicitly paint
a button or any other kind of control; you simply place them on the form and let
them automatically take care of painting themselves. So to place a button on a
form, you do it inside init( ):
|
|
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() :
|
|
|
|
|
//: c13:Button1.java
// Putting buttons on an 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");
public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
}
public static void main(String[] args) {
Console.run(new Button1(), 200, 50);
}
} ///:~
|
|
//: 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");
public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
}
public static void main(String[] args) {
Console.run(new Button1(), 200, 50);
}
} ///:~
|
|
|
|
Something new has been added here: before
any elements are placed on the content pane, it is given a new “layout
manager,” of type FlowLayout. The layout manager is the way that
the pane implicitly decides where to place the control on the form. The normal
behavior of an applet is to use the BorderLayout, but that won’t
work here because (as you will learn later in this chapter when controlling the
layout of a form is examined in more detail) it defaults to covering each
control entirely with every new one that is added. However, FlowLayout
causes the controls to flow evenly onto the form, left to right and top to
bottom.
|
|
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.
|
|
|
|
Capturing an event
|
|
Capture d'un événement
|
|
|
|
|
You’ll notice that if you compile
and run the applet above, nothing happens when you press the buttons. This is
where you must step in and write some code to determine what will happen. The
basis of event-driven
programming, which comprises a lot of what a GUI is about, is tying events to
code that responds to those events.
|
|
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.
|
|
|
|
|
The way that this is accomplished in Swing is by cleanly separating the interface (the graphical components) and the implementation (the code that you want to run when an event happens to a component). Each Swing component can report all the events that might happen to it, and it can report each kind of event individually. So if you’re not interested in, for example, whether the mouse is being moved over your button, you don’t register your interest in that event. It’s a very straightforward and elegant way to handle event-driven programming, and once you understand the basic concepts you can easily use Swing components that you haven’t seen before—in fact, this model extends to anything that can be classified as a JavaBean (which you’ll learn about later in the chapter). |
|
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).
|
|
|
|
|
At
first, we will just focus on the main event of interest for the components being
used. In the case of a JButton, this “event of interest” is
that the button is pressed. To register your interest in when a button is
pressed, you call the JButton’s addActionListener( )
method. This method expects an argument that is an object that implements the
ActionListener interface, which contains a single method called
actionPerformed( ). So all you have to do to attach code to a
JButton is to implement the ActionListener interface in a class,
and register an object of that class with the JButton via
addActionListener( ). The method will be called when the button is
pressed (this is normally referred to as a
callback).
|
|
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).
|
|
|
|
|
But what should the result of pressing
that button be? We’d like to see something change on the screen, so a new
Swing component will be introduced: the
JTextField. This is a place where text can be
typed, or in this case modified by the program. Although there are a number of
ways to create a JTextField, the simplest is just to tell the constructor
how wide you want that field to be. Once the JTextField is placed on the
form, you can modify its contents by using the setText( ) method
(there are many other methods in JTextField, but you must look these up
in the HTML documentation for the JDK from java.sun.com). Here is what it
looks like:
|
|
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 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 :
|
|
|
|
|
//: c13:Button2.java
// Responding to button presses.
// <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
b1 = new JButton("Button 1"),
b2 = new JButton("Button 2");
JTextField txt = new JTextField(10);
class BL implements ActionListener {
public void actionPerformed(ActionEvent e){
String name =
((JButton)e.getSource()).getText();
txt.setText(name);
}
}
BL al = new BL();
public void init() {
b1.addActionListener(al);
b2.addActionListener(al);
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
cp.add(txt);
}
public static void main(String[] args) {
Console.run(new Button2(), 200, 75);
}
} ///:~
|
|
//: 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
b1 = new JButton("Button 1"),
b2 = new JButton("Button 2");
JTextField txt = new JTextField(10);
class BL implements ActionListener {
public void actionPerformed(ActionEvent e){
String name =
((JButton)e.getSource()).getText();
txt.setText(name);
}
}
BL al = new BL();
public void init() {
b1.addActionListener(al);
b2.addActionListener(al);
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(b1);
cp.add(b2);
cp.add(txt);
}
public static void main(String[] args) {
Console.run(new Button2(), 200, 75);
}
} ///:~
|
|
|
|
|
|
|
|
|
|
|
|
|
