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.
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 :
//: 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 {
JTextArea t = new JTextArea(6, 15);
JCheckBox
cb1 = new JCheckBox("Check Box 1"),
cb2 = new JCheckBox("Check Box 2"),
cb3 = new JCheckBox("Check Box 3");
public void init() {
cb1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
trace("1", cb1);
}
});
cb2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
trace("2", cb2);
}
});
cb3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
trace("3", cb3);
}
});
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(new JScrollPane(t));
cp.add(cb1);
cp.add(cb2);
cp.add(cb3);
}
void trace(String b, JCheckBox cb) {
if(cb.isSelected())
t.append("Box " + b + " Set\n");
else
t.append("Box " + b + " Cleared\n");
}
public static void main(String[] args) {
Console.run(new CheckBoxes(), 200, 200);
}
} ///:~
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.
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énement des boutons radio s'interceptent comme tous les autres :
//: 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 {
JTextField t = new JTextField(15);
ButtonGroup g = new ButtonGroup();
JRadioButton
rb1 = new JRadioButton("one", false),
rb2 = new JRadioButton("two", false),
rb3 = new JRadioButton("three", false);
ActionListener al = new ActionListener() {
public void actionPerformed(ActionEvent e) {
t.setText("Radio button " +
((JRadioButton)e.getSource()).getText());
}
};
public void init() {
rb1.addActionListener(al);
rb2.addActionListener(al);
rb3.addActionListener(al);
g.add(rb1); g.add(rb2); g.add(rb3);
t.setEditable(false);
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(t);
cp.add(rb1);
cp.add(rb2);
cp.add(rb3);
}
public static void main(String[] args) {
Console.run(new RadioButtons(), 200, 100);
}
} ///:~
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.
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 appui sur un bouton.
//: 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 {
String[] description = { "Ebullient", "Obtuse",
"Recalcitrant", "Brilliant", "Somnescent",
"Timorous", "Florid", "Putrescent" };
JTextField t = new JTextField(15);
JComboBox c = new JComboBox();
JButton b = new JButton("Add items");
int count = 0;
public void init() {
for(int i = 0; i c.addItem(description[count++]);
t.setEditable(false);
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
if(count c.addItem(description[count++]);
}
});
c.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
t.setText("index: "+ c.getSelectedIndex()
+ " " + ((JComboBox)e.getSource())
.getSelectedItem());
}
});
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
cp.add(t);
cp.add(c);
cp.add(b);
}
public static void main(String[] args) {
Console.run(new ComboBoxes(), 200, 100);
}
} ///:~
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.
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".
//: 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 {
String[] flavors = { "Chocolate", "Strawberry",
"Vanilla Fudge Swirl", "Mint Chip",
"Mocha Almond Fudge", "Rum Raisin",
"Praline Cream", "Mud Pie" };
DefaultListModel lItems=new DefaultListModel();
JList lst = new JList(lItems);
JTextArea t = new JTextArea(flavors.length,20);
JButton b = new JButton("Add Item");
ActionListener bl = new ActionListener() {
public void actionPerformed(ActionEvent e) {
if(count lItems.add(0, flavors[count++]);
} else {
// Invalider, puisqu'il n'y a plus
// de parfums a ajouter a la liste
b.setEnabled(false);
}
}
};
ListSelectionListener ll = new ListSelectionListener() {
public void valueChanged(
ListSelectionEvent e) {
t.setText("");
Object[] items=lst.getSelectedValues();
for(int i = 0; i t.append(items[i] + "\n");
}
};
int count = 0;
public void init() {
Container cp = getContentPane();
t.setEditable(false);
cp.setLayout(new FlowLayout());
// Création de Bords pour les composants:
Border brd = BorderFactory.createMatteBorder(
1, 1, 2, 2, Color.black);
lst.setBorder(brd);
t.setBorder(brd);
// Ajout des quatre premiers élément à la liste
for(int i = 0; i lItems.addElement(flavors[count++]);
// Ajout des éléments au Content Pane pour affichage
cp.add(t);
cp.add(lst);
cp.add(b);
// Enregistrement des listeners d'événements
lst.addListSelectionListener(ll);
b.addActionListener(bl);
}
public static void main(String[] args) {
Console.run(new List(), 250, 375);
}
} ///:~
Quand on appuie sur le bouton il ajoute des élément 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.
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.
//: 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 {
String[] flavors = { "Chocolate", "Strawberry",
"Vanilla Fudge Swirl", "Mint Chip",
"Mocha Almond Fudge", "Rum Raisin",
"Praline Cream", "Mud Pie" };
JTabbedPane tabs = new JTabbedPane();
JTextField txt = new JTextField(20);
public void init() {
for(int i = 0; i tabs.addTab(flavors[i],
new JButton("Tabbed pane " + i));
tabs.addChangeListener(new ChangeListener(){
public void stateChanged(ChangeEvent e) {
txt.setText("Tab selected: " +
tabs.getSelectedIndex());
}
});
Container cp = getContentPane();
cp.add(BorderLayout.SOUTH, txt);
cp.add(tabs);
}
public static void main(String[] args) {
Console.run(new TabbedPane1(), 350, 200);
}
} ///:~
En Java, l'utilisation d'un mécanisme de panneaux à tabulations est
important car, pour la programmation d'applets, l'utilisation de dialogues pop-ups est
découragé 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.
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 :
//: 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 {
JButton[] b = { new JButton("Alert"),
new JButton("Yes/No"), new JButton("Color"),
new JButton("Input"), new JButton("3 Vals")
};
JTextField txt = new JTextField(15);
ActionListener al = new ActionListener() {
public void actionPerformed(ActionEvent e){
String id =
((JButton)e.getSource()).getText();
if(id.equals("Alert"))
JOptionPane.showMessageDialog(null,
"There's a bug on you!", "Hey!",
JOptionPane.ERROR_MESSAGE);
else if(id.equals("Yes/No"))
JOptionPane.showConfirmDialog(null,
"or no", "choose yes",
JOptionPane.YES_NO_OPTION);
else if(id.equals("Color")) {
Object[] options = { "Red", "Green" };
int sel = JOptionPane.showOptionDialog(
null, "Choose a Color!", "Warning",
JOptionPane.DEFAULT_OPTION,
JOptionPane.WARNING_MESSAGE, null,
options, options[0]);
if(sel != JOptionPane.CLOSED_OPTION)
txt.setText(
"Color Selected: " + options[sel]);
} else if(id.equals("Input")) {
String val = JOptionPane.showInputDialog(
"How many fingers do you see?");
txt.setText(val);
} else if(id.equals("3 Vals")) {
Object[] selections = {
"First", "Second", "Third" };
Object val = JOptionPane.showInputDialog(
null, "Choose one", "Input",
JOptionPane.INFORMATION_MESSAGE,
null, selections, selections[0]);
if(val != null)
txt.setText(
val.toString());
}
}
};
public void init() {
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
for(int i = 0; i b[i].addActionListener(al);
cp.add(b[i]);
}
cp.add(txt);
}
public static void main(String[] args) {
Console.run(new MessageBoxes(), 200, 200);
}
} ///:~
