 |
|
13) Création de fenêtres & d'Applets |
|
|
|
|
| Texte original |
|
Traducteur :
P. Boite |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
This reveals most of what the
Introspector sees as it produces a BeanInfo object from your Bean.
You can see that the type of the property and its name are independent. Notice
the lowercasing of the property name. (The only time this doesn’t occur is
when the property name begins with more than one capital letter in a row.) And
remember that the method names you’re seeing here (such as the read and
write methods) are actually produced from a Method object that can be
used to invoke the associated method on the object.
|
|
Ceci révèle la plus grosse partie de ce que voit
l'Introspector lorsqu'il produit un objet BeanInfo à partir d'un
Bean. On peut voir que le type de la propriété et son nom sont indépendants. Remarquons la
minuscule du nom de la propriété (la seule fois où ceci ne se produit pas est lorsque le nom de la
propriété commence par plus d'une majuscule l'une derrière l'autre). Il faut également retenir que
les noms de méthodes qu'on voit ici (tels que les noms des méthodes de lecture et d'écriture) sont
en fait obtenues à partir d'un objet Method qui peut être utilisé pour invoquer
les méthodes corrrespondantes de l'objet.
|
|
|
|
|
The public method list includes
the methods that are not associated with a property or event, such as
croak( ), as well as those that are. These are all the methods that
you can call programmatically for a Bean, and the application builder tool can
choose to list all of these while you’re making method calls, to ease your
task.
|
|
La liste des méthodes public contient les méthodes qui ne
sont pas associées à une propriété ou un événement, telles que croak(), ainsi que
celles qui le sont. Ce sont toutes les méthodes pouvant être appelées par programme pour un Bean,
et l'outil de construction d'applications peut décider de les lister toutes lors de la création des
appels de méthodes, pour nous faciliter la tâche.
|
|
|
|
Finally, you can see that the events are
fully parsed out into the listener, its methods, and the add- and
remove-listener methods. Basically, once you have the BeanInfo, you can
find out everything of importance for the Bean. You can also call the methods
for that Bean, even though you don’t have any other information except the
object (again, a feature of
reflection).
|
|
Enfin, on peut voir que les événements sont tous triés entre le
listener, ses méthodes et les méthodes pour ajouter et supprimer les listeners.
Fondamentalement, une fois obtenu le BeanInfo, on peut trouver tout ce qui est
important pour un Bean. On peut également appeler les méthodes de ce Bean, bien qu'on n'ait aucune
autre information à l'exception de l'objet (ceci est également une caractéristique de la
réflexion).
|
|
|
|
A more sophisticated Bean
|
|
Un Bean plus complexe
|
|
|
|
|
This next example is slightly more
sophisticated, albeit frivolous. It’s a JPanel that draws a little
circle around the mouse whenever the mouse is moved. When you press the mouse,
the word “Bang!” appears in the middle of the screen, and an action
listener is fired.
|
|
L'exemple suivant est un peu plus compliqué, bien que futile. Il s'agit
d'un JPanel qui dessine un petit cercle autour de la souris chaque fois qu'elle se
déplace. Lorsqu'on clique, le mot Bang! apparaît au milieu de l'écran, et un action
listener est appelé.
|
|
|
|
|
The properties you can change are the
size of the circle as well as the color, size, and text of the word that is
displayed when you press the mouse. A BangBean also has its own
addActionListener( ) and
removeActionListener( ) so you can attach
your own listener that will be fired when the user clicks on the
BangBean. You should be able to recognize the property and event
support:
|
|
Les propriétés modifiables sont la taille du cercle, ainsi que la couleur,
la taille et le texte du mot affiché lors du clic. Un BangBean a également ses propres
addActionListener() et removeActionListener(), de
sorte qu'on peut y attacher son propre listener qui sera appelé lorsque l'utilisateur clique sur le
BangBean. Vous devriez être capables de reconnaître le support des propriétés et
événements :
|
|
|
|
|
//: bangbean:BangBean.java
// A graphical Bean.
package bangbean;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import com.bruceeckel.swing.*;
public class BangBean extends JPanel
implements Serializable {
protected int xm, ym;
protected int cSize = 20; // Circle size
protected String text = "Bang!";
protected int fontSize = 48;
protected Color tColor = Color.red;
protected ActionListener actionListener;
public BangBean() {
addMouseListener(new ML());
addMouseMotionListener(new MML());
}
public int getCircleSize() { return cSize; }
public void setCircleSize(int newSize) {
cSize = newSize;
}
public String getBangText() { return text; }
public void setBangText(String newText) {
text = newText;
}
public int getFontSize() { return fontSize; }
public void setFontSize(int newSize) {
fontSize = newSize;
}
public Color getTextColor() { return tColor; }
public void setTextColor(Color newColor) {
tColor = newColor;
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.black);
g.drawOval(xm - cSize/2, ym - cSize/2,
cSize, cSize);
}
// This is a unicast listener, which is
// the simplest form of listener management:
public void addActionListener (
ActionListener l)
throws TooManyListenersException {
if(actionListener != null)
throw new TooManyListenersException();
actionListener = l;
}
public void removeActionListener(
ActionListener l) {
actionListener = null;
}
class ML extends MouseAdapter {
public void mousePressed(MouseEvent e) {
Graphics g = getGraphics();
g.setColor(tColor);
g.setFont(
new Font(
"TimesRoman", Font.BOLD, fontSize));
int width =
g.getFontMetrics().stringWidth(text);
g.drawString(text,
(getSize().width - width) /2,
getSize().height/2);
g.dispose();
// Call the listener's method:
if(actionListener != null)
actionListener.actionPerformed(
new ActionEvent(BangBean.this,
ActionEvent.ACTION_PERFORMED, null));
}
}
class MML extends MouseMotionAdapter {
public void mouseMoved(MouseEvent e) {
xm = e.getX();
ym = e.getY();
repaint();
}
}
public Dimension getPreferredSize() {
return new Dimension(200, 200);
}
} ///:~
|
|
//: bangbean:BangBean.java
// Un Bean graphique.
package bangbean;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import com.bruceeckel.swing.*;
public class BangBean extends JPanel
implements Serializable {
protected int xm, ym;
protected int cSize = 20; // Taille du cercle
protected String text = "Bang!";
protected int fontSize = 48;
protected Color tColor = Color.red;
protected ActionListener actionListener;
public BangBean() {
addMouseListener(new ML());
addMouseMotionListener(new MML());
}
public int getCircleSize() { return cSize; }
public void setCircleSize(int newSize) {
cSize = newSize;
}
public String getBangText() { return text; }
public void setBangText(String newText) {
text = newText;
}
public int getFontSize() { return fontSize; }
public void setFontSize(int newSize) {
fontSize = newSize;
}
public Color getTextColor() { return tColor; }
public void setTextColor(Color newColor) {
tColor = newColor;
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.black);
g.drawOval(xm - cSize/2, ym - cSize/2,
cSize, cSize);
}
// Ceci est un "unicast listener", qui est
// la forme la plus simple de gestion des listeners :
public void addActionListener (
ActionListener l)
throws TooManyListenersException {
if(actionListener != null)
throw new TooManyListenersException();
actionListener = l;
}
public void removeActionListener(
ActionListener l) {
actionListener = null;
}
class ML extends MouseAdapter {
public void mousePressed(MouseEvent e) {
Graphics g = getGraphics();
g.setColor(tColor);
g.setFont(
new Font(
"TimesRoman", Font.BOLD, fontSize));
int width =
g.getFontMetrics().stringWidth(text);
g.drawString(text,
(getSize().width - width) /2,
getSize().height/2);
g.dispose();
// Appel de la méthode du listener :
if(actionListener != null)
actionListener.actionPerformed(
new ActionEvent(BangBean.this,
ActionEvent.ACTION_PERFORMED, null));
}
}
class MML extends MouseMotionAdapter {
public void mouseMoved(MouseEvent e) {
xm = e.getX();
ym = e.getY();
repaint();
}
}
public Dimension getPreferredSize() {
return new Dimension(200, 200);
}
} ///:~
|
|
|
|
|
The first thing you’ll notice is
that BangBean implements the
Serializable interface.
This means that the application builder tool can “pickle” all the
information for the BangBean using serialization after the program
designer has adjusted the values of the properties. When the Bean is created as
part of the running application, these “pickled” properties are
restored so that you get exactly what you designed.
|
|
La première chose qu'on remarquera est que BangBean
implémente l'interface Serializable. Ceci signifie que l'outil de construction
d'applications peut conserver toutes les informations sur le BangBean en utilisant
la sérialisation, lorsque les valeurs des propriétés ont été ajustées par l'utilisateur. Lors de la
création du Bean au moment de l'exécution du programme, ces propriétés sauvegardées sont restaurées
de manière à obtenir exactement ce qu'elles valaient lors de la conception.
|
|
|
|
|
You can see that all the fields are
private, which is what you’ll usually do with a Bean—allow
access only through methods, usually using the “property”
scheme.
|
|
On peut voir que tous les champs sont private, ce qu'on
fait en général avec un Bean : autoriser l'accès uniquement à travers des méthodes, normalement en
utilisant le système de propriétés.
|
|
|
|
|
When you look at the signature for
addActionListener( ), you’ll see that it can throw a
TooManyListenersException. This indicates that it
is unicast, which means it notifies only one
listener when the event occurs. Ordinarily, you’ll use
multicast events so that many listeners can be
notified of an event. However, that runs into issues that you won’t be
ready for until the next chapter, so it will be revisited there (under the
heading “JavaBeans revisited”). A unicast event sidesteps the
problem.
|
|
En observant la signature de addActionListener(), on
voit qu'il peut émettre une TooManyListenersException. Ceci indique qu'il est
unicast, ce qui signifie qu'il signale à un seul listener l'arrivée d'un
événement. En général on utilise des événements multicast, de sorte que de nombreux
listeners puissent être notifiés de l'arrivée d'un événement. Cependant on entre ici dans
des problèmes que vous ne pouvez pas comprendre avant le chapitre suivant; on en reparlera donc
(sous le titre «JavaBeans revisited»). Un événement unicast contourne le
problème.
|
|
|
|
|
When you click the mouse, the text is put
in the middle of the BangBean, and if the actionListener field is
not null, its actionPerformed( ) is called, creating a new
ActionEvent object in the process. Whenever the
mouse is moved, its new coordinates are captured and the canvas is repainted
(erasing any text that’s on the canvas, as you’ll
see).
|
|
Lorsqu'on clique avec la souris, le texte est placé au milieu du
BangBean, et si le champ de l'actionListener n'est pas nul, on
appelle son actionPerformed(), ce qui crée un nouvel objet
ActionEvent. Lorsque la souris est déplacée, ses nouvelles coordonnées sont lues
et le panneau est redessiné (ce qui efface tout texte sur ce panneau, comme on le
remarquera).
|
|
|
|
|
Here is the BangBeanTest class to
allow you to test the bean as either an applet or an
application:
|
|
Voici la classe BangBeanTest permettant de tester le
bean en tant qu'applet ou en tant qu'application :
|
|
|
|
|
//: c13:BangBeanTest.java
// <applet code=BangBeanTest
// width=400 height=500></applet>
import bangbean.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;
public class BangBeanTest extends JApplet {
JTextField txt = new JTextField(20);
// During testing, report actions:
class BBL implements ActionListener {
int count = 0;
public void actionPerformed(ActionEvent e){
txt.setText("BangBean action "+ count++);
}
}
public void init() {
BangBean bb = new BangBean();
try {
bb.addActionListener(new BBL());
} catch(TooManyListenersException e) {
txt.setText("Too many listeners");
}
Container cp = getContentPane();
cp.add(bb);
cp.add(BorderLayout.SOUTH, txt);
}
public static void main(String[] args) {
Console.run(new BangBeanTest(), 400, 500);
}
} ///:~
|
|
//: c13:BangBeanTest.java
// <applet code=BangBeanTest
// width=400 height=500></applet>
import bangbean.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;
public class BangBeanTest extends JApplet {
JTextField txt = new JTextField(20);
// Affiche les actions lors des tests :
class BBL implements ActionListener {
int count = 0;
public void actionPerformed(ActionEvent e){
txt.setText("BangBean action "+ count++);
}
}
public void init() {
BangBean bb = new BangBean();
try {
bb.addActionListener(new BBL());
} catch(TooManyListenersException e) {
txt.setText("Too many listeners");
}
Container cp = getContentPane();
cp.add(bb);
cp.add(BorderLayout.SOUTH, txt);
}
public static void main(String[] args) {
Console.run(new BangBeanTest(), 400, 500);
}
} ///:~
|
|
|
|
|
When a Bean is in a development
environment, this class will not be used, but it’s helpful to provide a
rapid testing method for each of your Beans. BangBeanTest places a
BangBean within the applet, attaching a simple ActionListener to
the BangBean to print an event count to the JTextField whenever an
ActionEvent occurs. Usually, of course, the application builder tool
would create most of the code that uses the Bean.
|
|
Lorsqu'un Bean est dans un environnement de développement, cette
classe n'est pas utilisée, mais elle est utile pour fournir une méthode de test rapide pour chacun
de nos Beans. BangBeanTest place un BangBean dans une
applet, attache un simple ActionListener au BangBean pour
afficher un compteur d'événements dans le JTextField chaque fois qu'un ActionEvent
arrive. En temps normal, bien sûr, l'outil de construction d'applications créerait la plupart du
code d'utilisation du Bean.
|
|
|
|
When you run the BangBean through
BeanDumper or put the BangBean inside a Bean-enabled development
environment, you’ll notice that there are many more properties and actions
than are evident from the above code. That’s because BangBean is
inherited from JPanel, and JPanel is also Bean, so you’re
seeing its properties and events as
well.
|
|
Lorsqu'on utilise le BangBean avec le
BeanDumper, ou si on place le BangBean dans un environnement de
développement acceptant les Beans, on remarquera qu'il y a beaucoup plus de propriétés et
d'actions que ce qui n'apparaît dans le code ci-dessus. Ceci est dû au fait que
BangBean hérite de JPanel, et comme JPanel est
également un Bean, on en voit également ses propriétés et événements.
|
|
|
|
Packaging a
Bean
|
|
Empaquetage d'un Bean
|
|
|
|
|
Before you can bring a Bean into a
Bean-enabled visual builder tool, it must be put into the standard Bean
container, which is a JAR file that includes all the Bean classes as well as a
“manifest” file that says “This is a Bean.” A manifest
file is simply a text file that follows a particular form. For the
BangBean, the manifest file looks like this (without the first and last
lines):
|
|
Pour installer un Bean dans un outil de développement visuel
acceptant les Beans, le Bean doit être mis dans le conteneur standard des
Beans, qui est un fichier JAR contenant toutes les classes, ainsi qu'un fichier
manifest qui dit «ceci est un Bean». Un fichier manifest est un simple fichier
texte avec un format particulier. Pour le BangBean, le fichier manifest ressemble
à ceci (sans la première et la dernière ligne) :
|
|
|
|
|
//:! :BangBean.mf
Manifest-Version: 1.0
Name: bangbean/BangBean.class
Java-Bean: True
///:~
|
|
//:! :BangBean.mf
Manifest-Version: 1.0
Name: bangbean/BangBean.class
Java-Bean: True
///:~
|
|
|
|
|
The first line indicates the version of
the manifest scheme, which until further notice from Sun is 1.0. The second line
(empty lines are ignored) names the BangBean.class file, and the third
says, “It’s a Bean.” Without the third line, the program
builder tool will not recognize the class as a Bean.
|
|
La première ligne indique la version de la structure du fichier manifest,
qui est 1.0 jusqu'à nouvel ordre de chez Sun. la deuxième ligne (les lignes vides étant ignorées)
nomme le fichier BangBean.class, et la troisième précise que c'est un Bean. Sans
la troisième ligne, l'outil de construction de programmes ne reconnaîtra pas la classe en tant que
Bean.
|
|
|
|
|
The only tricky part is that you must
make sure that you get the proper path in the “Name:” field. If you
look back at BangBean.java, you’ll see it’s in package
bangbean (and thus in a subdirectory called “bangbean”
that’s off of the classpath), and the name in the manifest file must
include this package information. In addition, you must place the manifest file
in the directory above the root of your package path, which in this case
means placing the file in the directory above the “bangbean”
subdirectory. Then you must invoke jar from the same directory as the
manifest file, as follows:
|
|
Le seul point délicat est de s'assurer d'avoir le bon chemin dans le champ
«Name:». Si on retourne à BangBean.java, on voit qu'il est dans le package
bangbean (et donc dans un sous-répertoire appelé bangbean qui est en dehors du classpath),
et le nom dans le fichier manifest doit contenir cette information de package. De plus, il faut
placer le fichier manifest dans le répertoire au-dessus de la racine du package, ce qui
dans notre cas veut dire le placer dans le répertoire au-dessus du répertoire bangbean. Ensuite il
faut lancer jar depuis le répertoire où se trouve le fichier manifest, de la façon
suivante :
|
|
|
|
|
jar cfm BangBean.jar BangBean.mf bangbean
|
|
jar cfm BangBean.jar BangBean.mf bangbean
|
|
|
|
|
This assumes that you want the resulting
JAR file to be named BangBean.jar and that you’ve put the manifest
in a file called BangBean.mf.
|
|
Ceci suppose qu'on veut que le fichier JAR résultant s'appelle
BangBean.jar, et qu'on a placé le fichier manifest dans un fichier appelé
BangBean.mf.
|
|
|
|
|
You might wonder “What about all
the other classes that were generated when I compiled
BangBean.java?” Well, they all ended up inside the bangbean
subdirectory, and you’ll see that the last argument for the above
jar command line is the bangbean subdirectory. When you give
jar the name of a subdirectory, it packages that entire subdirectory into
the jar file (including, in this case, the original BangBean.java
source-code file—you might not choose to include the source with your own
Beans). In addition, if you turn around and unpack the JAR file you’ve
just created, you’ll discover that your manifest file isn’t inside,
but that jar has created its own manifest file (based partly on yours)
called MANIFEST.MF and placed it inside the subdirectory META-INF
(for “meta-information”). If you open this manifest file
you’ll also notice that digital signature information has been added by
jar for each file, of the form:
|
|
On peut se demander ce qui se passe pour les autres classes générées
lorsqu'on a compilé BangBean.java. Eh bien, elles ont toutes abouti dans le
sous-répertoire bangbean. Lorsqu'on donne à la commande jar le
nom d'un sous-répertoire, il embarque tout le contenu de ce sous-répertoire dans le fichier jar (y
compris, dans notre cas, le code source original BangBean.java qu'on peut ne pas
vouloir inclure dans les Beans). Si on regarde à l'intérieur du fichier JAR, on découvre que le
fichier manifest n'y est pas, mais que jar a créée son propre fichier manifest
(partiellement sur la base du nôtre) appelé MANIFEST.MF et l'a placé dans le
sous-répertoire META-INF (pour meta-information). Si on ouvre ce fichier manifest
on remarquera également qu'une information de signature numérique a été ajoutée par
jar pour chaque fichier, de la forme :
|
|
|
|
|
Digest-Algorithms: SHA MD5
SHA-Digest: pDpEAG9NaeCx8aFtqPI4udSX/O0=
MD5-Digest: O4NcS1hE3Smnzlp2hj6qeg==
|
|
Digest-Algorithms: SHA MD5
SHA-Digest: pDpEAG9NaeCx8aFtqPI4udSX/O0=MD5-Digest: O4NcS1hE3Smnzlp2hj6qeg==
|
|
|
|
|
In general, you don’t need to worry
about any of this, and if you make changes you can just modify your original
manifest file and reinvoke jar to create a new JAR file for your Bean.
You can also add other Beans to the JAR file simply by adding their information
to your manifest.
|
|
En général, on ne se préoccupe pas de tout ceci, et lors de modifications
il suffit de modifier le fichier manifest d'origine et rappeler jar pour créer un
nouveau fichier JAR pour le Bean. On peut aussi ajouter d'autres Beans dans le
fichier JAR en ajoutant simplement leurs informations dans le manifest.
|
|
|
|
|
One thing to notice is that you’ll
probably want to put each Bean in its own subdirectory, since when you create a
JAR file you hand the jar utility the name of a subdirectory and it puts
everything in that subdirectory into the JAR file. You can see that both
Frog and BangBean are in their own
subdirectories.
|
|
Une chose à remarquer est qu'on mettra probablement chaque Bean dans son
propre sous-répertoire, puisque lorsqu'on crée un fichier JAR on passe à la commande
jar le nom d'un sous-répertoire et qu'il place tout ce qui est dans ce répertoire
dans le fichier JAR. On peut voir que Frog et BangBean sont
chacun dans leur propre sous-répertoire.
|
|
|
|
Once you have your Bean properly inside a
JAR file you can bring it into a Beans-enabled program-builder environment. The
way you do this varies from one tool to the next, but Sun provides a freely
available test bed for JavaBeans in their “Beans Development Kit”
(BDK) called the
“beanbox.” (Download
the BDK from java.sun.com/beans.) To place your Bean in the beanbox, copy
the JAR file into the BDK’s “jars” subdirectory before you
start up the beanbox.
|
|
Une fois le Bean convenablement inséré dans un fichier JAR, on peut
l'installer dans un environnement de développement de programmes acceptant les Beans. La façon de
le faire varie d'un outil à l'autre, mais Sun fournit gratuitement un banc de test pour les
JavaBeans dans leur Beans Development Kit (BDK) appelé la beanbox (le BDK se
télécharge à partir de java.sun.com/beans). Pour placer un Bean dans la beanbox,
il suffit de copier le fichier JAR dans le sous-répertoire jars du BDK avant de lancer la
beanbox.
|
|
|
|
More complex Bean support
|
|
Un support des Beans plus sophistiqué
|
|
|
|
|
You can see how remarkably simple it is
to make a Bean. But you aren’t limited to what you’ve seen here. The
JavaBeans architecture provides a simple point of entry but can also scale to
more complex situations. These situations are beyond the scope of this book, but
they will be briefly introduced here. You can find more details at
java.sun.com/beans.
|
|
On a vu comme il était simple de fabriquer un Bean. Mais on n'est pas
limité à ce qu'on a vu ici. L'architecture des JavaBeans fournit un point d'entrée simple, mais
peut aussi s'adapter à des cas plus complexes. Ceux-ci ne sont pas du ressort de ce livre, mais on
va les introduire rapidement ici. On trouvera plus de détails à
java.sun.com/beans.
|
|
|
|
|
One place where you can add
sophistication is with properties. The examples above have shown only single
properties, but it’s also possible to represent multiple properties in an
array. This is called an
indexed
property. You simply provide the appropriate methods (again following a
naming convention for the method names) and the Introspector recognizes
an indexed property so your application builder tool can respond
appropriately.
|
|
Un endroit où l'on peut apporter des perfectionnements est le traitement
des propriétés. Les exemples ci-dessus n'ont montré que des propriétés uniques, mais il est
également possible de représenter plusieurs propriétés dans un tableau. C'est ce qu'on appelle une
propriété indexée [indexed property]. Il suffit de fournir les méthodes
appropriées (également en suivant une convention de nommage pour les noms de méthodes) et
l'Introspector reconnaît une propriété indexée, de sorte qu'un outil de
construction d'applications puisse y répondre correctement.
|
|
|
|
|
Properties can be
bound,
which means that they will notify other objects via a
PropertyChangeEvent. The other objects can then choose to change
themselves based on the change to the Bean.
|
|
Les propriétés peuvent être liées [bound], ce qui signifie
qu'elles avertiront les autres objets à l'aide d'un PropertyChangeEvent. Les
autres objets peuvent alors décider de se modifier eux-mêmes suite à la modification de ce
Bean.
|
|
|
|
|
Properties can be
constrained,
which means that other objects can veto a change to that property if it is
unacceptable. The other objects are notified using a
PropertyChangeEvent, and
they can throw a
PropertyVetoException to
prevent the change from happening and to restore the old
values.
|
|
Les propriétés peuvent être contraintes [constrained], ce qui
signifie que les autres objets peuvent mettre leur veto sur la modification de cette propriété si
c'est inacceptable. Les autres objets sont avertis à l'aide d'un PropertyChangeEvent, et ils peuvent émettre un
PropertyVetoException pour empêcher la modification et pour rétablir les anciennes
valeurs.
|
|
|
|
|
You
can also change the way your Bean is represented at design
time:
|
|
On peut également modifier la façon de représenter le Bean lors de la
conception :
|
|
|
|
- You can provide a custom
property sheet for your particular Bean. The ordinary property sheet will be
used for all other Beans, but yours is automatically invoked when your Bean is
selected.
- You can
create a custom editor for a particular property, so the ordinary property sheet
is used, but when your special property is being edited, your editor will
automatically be
invoked.
- You can
provide a custom BeanInfo class for your Bean that produces information
that’s different from the default created by the
Introspector.
- It’s
also possible to turn “expert” mode on and off in all
FeatureDescriptors to distinguish between basic features and more
complicated
ones.
|
|
- On peut fournir une feuille de propriétés spécifique pour un Bean
particulier. La feuille de propriétés normale sera utilisée pour tous les autres Beans, mais la
feuille spéciale sera automatiquement appelée lorsque ce Bean sera sélectionné.
- On peut créer un éditeur spécifique pour une propriété particulière, de
sorte que la feuille de propriétés normale est utilisée, mais si on veut éditer cette propriété,
c'est cet éditeur qui est automatiquement appelé.
- On peut fournir une classe BeanInfo spécifique pour un
Bean donné, pour fournir des informations différentes de celles créées par défaut par
l'Introspector.
- Il est également possible de valider ou dévalider le mode expert dans tous
les FeatureDescriptors pour séparer les caractéristiques de base de celles plus
compliquées.
|
|
|
|
More to Beans
|
|
Davantage sur les Beans
|
|
|
|
|
There’s another issue that
couldn’t be addressed here. Whenever you create a Bean, you should expect
that it will be run in a multithreaded environment. This means that you must
understand the issues of threading, which will be introduced in Chapter 14.
You’ll find a section there called “JavaBeans revisited” that
will look at the problem and its solution.
|
|
Il y a un autre problème qui n'a pas été traité ici. Chaque fois qu'on crée
un Bean, on doit s'attendre à ce qu'il puisse être exécuté dans un environnement
multithread. Ceci signifie qu'il faut comprendre les problèmes du threading, qui
sera présenté au Chapitre 14. On y trouvera un paragraphe appelé «JavaBeans revisited» qui
parlera de ce problème et de sa solution.
|
|
|
|
There are a number of books about
JavaBeans; for example, JavaBeans by Elliotte Rusty Harold (IDG,
1998).
|
|
Il y a plusieurs livres sur les JavaBeans, par exemple JavaBeans
par Elliotte Rusty Harold (IDG, 1998).
|
|
|
|
Summary
|
|
Résumé
|
|
|
|
|
Of all the libraries in Java, the GUI
library has seen the most dramatic changes from Java 1.0 to Java 2. The Java 1.0
AWT was roundly criticized as being one of the worst designs seen, and while it
would allow you to create portable programs, the resulting GUI was
“equally mediocre on all platforms.” It was also limiting, awkward,
and unpleasant to use compared with the native application development tools
available on a particular platform.
|
|
De toutes les librairies Java, c'est la librairie de GUI qui a subi les
changements les plus importants de Java 1.0 à Java 2. L'AWT de Java 1.0 était nettement critiqué
comme étant une des moins bonnes conceptions jamais vues, et bien qu'il permette de créer des
programmes portables, la GUI résultante était aussi médiocre sur toutes les plateformes. Il était
également limité, malaisé et peu agréable à utiliser en comparaison des outils de développement
natifs disponibles sur une plate-forme donnée.
|
|
|
|
|
When Java 1.1 introduced the new event
model and JavaBeans, the stage was set—now it was possible to create GUI
components that could be easily dragged and dropped inside visual application
builder tools. In addition, the design of the event model and Beans clearly
shows strong consideration for ease of programming and maintainable code
(something that was not evident in the 1.0 AWT). But it wasn’t until the
JFC/Swing classes appeared that the job was finished. With the Swing components,
cross-platform GUI programming can be a civilized experience.
|
|
Lorsque Java 1.1 introduisit le nouveau modèle d'événements et les
JavaBeans, la scène était installée. Il était désormais possible de créer des composants de GUI
pouvant être facilement glissés et déposés à l'intérieur d'outils de développement visuels. De
plus, la conception du modèle d'événements et des Beans montre l'accent mis sur la facilité de
programmation et la maintenabilité du code (ce qui n'était pas évident avec l'AWT du 1.0). Mais le
travail ne s'est terminé qu'avec l'apparition des classes JFC/Swing. Avec les composants Swing, la
programmation de GUI toutes plateformes devient une expérience civilisée.
|
|
|
|
|
Actually, the only thing that’s
missing is the application builder tool, and this is where the real revolution
lies. Microsoft’s Visual Basic and Visual C++
require Microsoft’s application builder tools, as does
Borland’s Delphi and C++ Builder. If you want the
application builder tool to get better, you have to cross your fingers and hope
the vendor will give you what you want. But Java is an open environment, and so
not only does it allow for competing application builder environments, it
encourages them. And for these tools to be taken seriously, they must support
JavaBeans. This means a leveled playing field: if a better application builder
tool comes along, you’re not tied to the one you’ve been
using—you can pick up and move to the new one and increase your
productivity. This kind of competitive environment for GUI application builder
tools has not been seen before, and the resulting marketplace can generate only
positive results for the productivity of the programmer.
|
|
En fait, la seule chose qui manque est l'outil de développement, et c'est
là que se trouve la révolution. Visual Basic et Visual C++ de Microsoft nécessitent des outils de
développement de Microsoft, et il en est de même pour Delphi et C++ Builder de Borland. Si on
désire une amélioration de l'outil, on n'a plus qu'à croiser les doigts et espérer que le
fournisseur le fera. Mais java est un environnement ouvert, et de ce fait, non seulement il permet
la compétition des outils, mais il l'encourage. Et pour que ces outils soient pris au sérieux, ils
doivent permettre l'utilisation des JavaBeans. Ceci signifie un terrain de jeu nivelé : si un
meilleur outil de développement apparaît, on n'est pas lié à celui qu'on utilisait jusqu'alors, on
peut migrer vers le nouvel outil et augmenter sa productivité. Cet environnement compétitif pour
les outils de développement ne s'était jamais vu auparavant, et le marché résultant ne peut que
générer des résultats positifs pour la productivité du programmeur.
|
|
|
|
|
This chapter was meant only to give you an introduction to the power of Swing and to get you started so you could see how relatively simple it is to feel your way through the libraries. What you’ve seen so far will probably suffice for a good portion of your UI design needs. However, there’s a lot more to Swing—it’s intended to be a fully powered UI design tool kit. There’s probably a way to accomplish just about everything you can imagine. |
|
Ce chapitre était uniquement destiné à vous fournir une introduction à la
puissance de Swing et vous faire démarrer, et vous avez pu voir comme il était simple de trouver
son chemin à travers les librairies. Ce qu'on a vu jusqu'ici suffira probablement pour une bonne
part à vos besoins en développement d'interfaces utilisateurs. Cependant, Swing ne se limite pas
qu'à cela. Il est destiné à être une boîte à outils de conception d'interfaces utilisateurs très
puissante. Il y a probablement une façon de faire à peu près tout ce qu'on peut
imaginer.
|
|
|
|
If
you don’t see what you need here, delve into the online documentation from
Sun and search the Web, and if that’s not enough then find a dedicated
Swing book—a good place to start is The JFC Swing Tutorial, by
Walrath & Campione (Addison Wesley, 1999).
|
|
Si vous ne trouvez pas ici ce dont vous avez besoin, fouillez dans la
documentation en ligne de Sun, et recherchez sur le Web, et si cela ne suffit pas, cherchez un
livre consacré à Swing. Un bon endroit pour démarrer est The JFC Swing Tutorial, par
Walrath & Campione (Addison Wesley, 1999).
|
|
|
|
|
|
|
|
|
|
|
|
|
