Nous allons créer une mini-application swing qui permettra de choisir le style des composants qu'elle contient à l'aide d'un bouton.
La classe principale sera une classe dérivée du type Object. La fenêtre dans laquelle l'application s'exécute ainsi que les composants qu'elle contient seront des champs de cette classe.
import javax.swing.*; //package swing
import java.awt.*;
import java.awt.event.*;
public class SwingApplication {
JFrame fen; //fenêtre de l'application
JButton changeLAF; //bouton changement de style
JLabel nomStyle; //nom du style utilisé
Le constructeur va créer la fenêtre, ajouter les composants qu'elle contient, puis l'afficher. La création et l'ajout des composants seront gérés par la méthode panelPrincipal qui fournira un objet de type JPanel (Panel swing). Il nous suffira donc d'ajouter ce JPanel à la fenêtre. Cette opération ne se fait plus directement par la méthode add comme avec AWT. Nous devrons passer par un container fourni par la méthode getContentPane de la fenêtre. On obtient le code suivant:
public SwingApplication() {
//création de la fenêtre
fen=new JFrame("Application Swing");
//ajout des composants
fen.getContentPane().add(panelPrincipal(), BorderLayout.CENTER);
//écouteur pour fermeture de la fenêtre
fen.addWindowListener(new Fermeture());
//mise en place et affichage
fen.pack();
fen.setBounds(50,50,200,150);
fen.setVisible(true);
}
Cette méthode fournit un composant de type JPanel contenant les composants de l'application : ici un JLabel (Label swing) et un JButton (Button swing). On utilisera un gestionnaire de positionnement de type GridLayout.
La classe UIManager nous permet de connaitre le nom du style d'affichage choisi.
Les composants swing disposent d'une méthode setBorder qui permet de leur attribuer une bordure fournie par l'une des méthodes (statiques) de la classe BorderFactory.
public Component panelPrincipal() {
//-------------label nom de style (look and feel)
nomStyle=new JLabel("LAF: "+UIManager.getLookAndFeel().getName(),
SwingConstants.CENTER);
//-------------bouton de changement de style
changeLAF=new JButton("Change");
//écouteur du bouton
changeLAF.addActionListener(new ActionBouton());
//-------------le JPanel qui contient le reste
JPanel pane=new JPanel();
//définir une bordure, ici vide avec marge
pane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
//ajout des composants
pane.setLayout(new GridLayout(2,1,10,10));
pane.add(nomStyle);
pane.add(changeLAF);
return pane;
}
Nous avons à créer les classes Fermeture et ActionBouton qui représentent les écouteurs d'évènements liés à la fenêtre et au bouton.
La classe Fermeture ferme la fenêtre et met fin à l'application.
class Fermeture extends WindowAdapter {
public void windowClosing(WindowEvent e) {
fen.setVisible(false);
System.exit(0);
}
}
La classe ActionBouton fournit la méthode actionPerformed que nous laisserons vide dans un premier temps.
class ActionBouton implements ActionListener {
public void actionPerformed(ActionEvent e) {
}
}
La méthode main de l'application se contente de créer une instance de la classe SwingApplication.
public static void main(String[] args) {
System.out.println("Chargement en cours...");
new SwingApplication();
}
Le package swing permet de choisir parmi plusieurs styles de composants; ainsi l'application précédemment écrite pourra prendre l'une des trois formes suivantes :
|
|
|
|
La classe UIManager fournit les méthodes de gestion des styles d'application. Retenons les méthodes :
Nous ajoutons à la classe SwingApplication deux champs supplémentaires :
Ceci donne les déclarations suivantes à ajouter:
UIManager.LookAndFeelInfo laf[]; //styles disponibles
int lafNo=0; //numéro style courant
Le tableau des styles est initialisé dans le constructeur grâce à la méthode fournie par la classe UIManager.
//chargement des styles disponibles
laf=UIManager.getInstalledLookAndFeels();
Nous pouvons maintenant compléter la classe ActionBouton pour effectuer les changements de styles. A chaque appui sur le bouton change on incrémente le numéro du style courant en revenant à 0 après le dernier, puis on l'installe. La méthode actionPerformed devient donc :
public void actionPerformed(ActionEvent e) {
//on passe au numéro de style suivant ou 0
lafNo=(lafNo+1) % laf.length;
//on essaie d'effectuer le changement
try {
UIManager.setLookAndFeel(laf[lafNo].getClassName());
SwingUtilities.updateComponentTreeUI(fen);
//mise à jour du label contenant le nom du style
nomStyle.setText("LAF: "+UIManager.getLookAndFeel().getName());
} catch (Exception exc) {}
fen.repaint();
}
La méthode updateComponentTreeUI fournie par la classe SwingUtilities permet d'appeler la méthode updateUI de chacun des composants contenus dans la fenêtre de façon à les mettre à jour pour le nouveau style actif.