Développons en Java

13/07/2003

[ Précédent ] [ Sommaire ] [ Suivant ] [ Télécharger ]

13. Le développement d'interface graphique avec SWING
13.1. Présentation de Swing
13.2. Les packages Swing
13.3. Un exemple de fenêtre autonome
13.4. Les composants Swing
13.4.1. La classe JFrame
13.4.1.1. Le comportement par défaut à la fermeture
13.4.1.2. La personnalisation de l'icone
13.4.1.3. Centrer une JFrame à l'écran
13.4.1.4. Les évenements associées à un JFrame
13.4.2. Les étiquettes : la classe JLabel
13.4.3. Les panneaux : la classe Jpanel
13.5. Les boutons
13.5.1. La classe AbstractButton
13.5.2. La classe JButton : les boutons
13.5.3. La classe JToggleButton
13.5.4. La classe ButtonGroup
13.5.5. Les cases à cocher : la classe JCheckBox
13.5.6. Les boutons radio : la classe JRadioButton

13. Le développement d'interface graphique avec SWING

Swing fait partie de la bibliothèque Java Foundation Classes. C'est une extension de l'AWT qui a été intégrée au JDK depuis sa version 1.2. Cette bibliothèque existe séparement pour le JDK 1.1.

La bibliothèque JFC contient :

l'API Swing : de nouvelles classes et interfaces pour construire des interfaces graphiques
Accessibility API :
2D API: support de graphisme en 2D
API pour l'impression et le cliquer-glisser

13.1. Présentation de Swing

Swing propose de nombreux composants dont certains possède des fonctions étendues, une utilisation des mécanismes de gestion d'événements performants (ceux introduits par le JDK 1.1) et une apparence modifiable à la volée (une interface qui emploie le style du système d'exploitation Windows ou Motif ou un nouveau style spécifique à Java nommé Metal).

Tous les éléments de Swing font partie d'un package qui a changé plusieurs fois de nom : le nom du package dépend de la version du J.D.K. utilisé :

com.sun.java.swing : jusqu'à la version 1.1 beta 2 de Swing des JFC 1.1 et J.D.K. 1.2 beta 4
java.awt.swing : utilisé par le J.D.K. 1.2 beta 2 et 3
javax.swing : à partir des versions de Swing 1.1 beta 3 et J.D.K. 1.2 RC1

Les composants Swing forment un nouvelle hériarchie parallèle à celle de l'AWT. L'ancètre de cette hiérarchie est le composant JComponent. Presque tous ces composants sont écrits en pure Java : ils ne possèdent aucune partie native sauf ceux qui assurent l'interface avec le système d'exploitation : JApplet, JDialog, JFrame, et JWindow. Cela permet aux composants de toujours avoir la même apparence quelque soit le système.

Tous les composants Swing possèdent les caractèristiques suivantes :

ce sont des beans
ce sont des composants légers (pas de partie native) hormis quelques exceptions.
leurs bords peuvent être changés

La procédure à suivre pour utiliser un composant Swing est identique à celle des composants AWT : créer le composant en appelant son constructeur, appeler les méthodes du composant si nécessaire pour le personnaliser et l'ajouter dans un conteneur.

Swing utilise la même infrastructure de classes que AWT, ce qui permet de mélanger des composants Swing et AWT dans la même interface. Sun recommande toutefois d'éviter de les mélanger car certains peuvent ne pas être restitués correctement.

Les composants Swing utilisent des modèles pour contenir leurs états ou leur données. Ces modèles sont des classes particulières qui possèdent toutes un comportement par défaut.

13.2. Les packages Swing

Swing contient plusieurs packages :

javax.swing	package principal : il contient les interfaces, les principaux composants, les modèles par défaut
javax.swing.border	Classes représentant les bordures
javax.swing.colorchooser	Classes définissant un composant pour la sélection de couleurs
javax.swing.event	Classes et interfaces pour les événements spécifique à Swing. Les autres événements sont ceux de AWT (java.awt.event)
javax.swing.filechooser	Classes définissant un composant pour la sélection de fichiers
javax.swing.plaf	Classes et interfaces génériques pour gérer l'apparence
javax.swing.plaf.basic	Classes et interfaces de base pour gérer l'apparence
javax.swing.plaf.metal	Classes et interfaces pour définir l'apparence Metal qui est l'apparence par défaut
javax.swing.table	Classes définissant un composant pour la présentation de données sous forme de tableau
javax.swing.text	Classes et interfaces de bases pour les composants manipulant du texte
javax.swing.text.html	Classes permettant le support du format HTML
javax.swing.text.html.parser	Classes permettant d'analyser des données au format HTML
javax.swing.text.rtf	Classes permettant le support du format RTF
javax.swing.tree	Classes définissant un composant pour la présentation de données sous forme d'arbre
javax.swing.undo	Classes permettant d'implémenter les fonctions annuler/refaire

13.3. Un exemple de fenêtre autonome

La classe de base d'une application est la classe JFrame. Son rôle est équivalent à la classe Frame de l'AWT et elle s'utilise de la même façon

import javax.swing.*;
import java.awt.event.*;
public class swing1 extends JFrame {
   public swing1() {
      super("titre de l'application");
      WindowListener l = new WindowAdapter() {
         public void windowClosing(WindowEvent e){
            System.exit(0);
         }
      };
      addWindowListener(l);
      setSize(200,100);
      setVisible(true);
   }
   public static void main(String [] args){
      JFrame frame = new swing1();
   }
}

13.4. Les composants Swing

Il existe des composants Swing équivalents pour chacun des composants AWT avec des constructeurs semblables. De nombreux constructeurs acceptent comme argument un objet de type Icon, qui représente une petite image généralement stockée au format Gif.

Le constructeur d'un objet Icon admet comme seul paramètre le nom ou l'URL d'un fichier graphique

import javax.swing.*;
import java.awt.event.*;
public class swing3 extends JFrame {
  public swing3() {
     super("titre de l'application");
      WindowListener l = new WindowAdapter() {
         public void windowClosing(WindowEvent e){
            System.exit(0);
         }
      };
      addWindowListener(l);
      ImageIcon img = new ImageIcon("tips.gif");
      JButton bouton = new JButton("Mon bouton",img);
      JPanel panneau = new JPanel();
      panneau.add(bouton);
      setContentPane(panneau);
      setSize(200,100);
      setVisible(true);
   }
  public static void main(String [] args){
      JFrame frame = new swing3();
  }
}

13.4.1. La classe JFrame

JFrame est l'équivalent de la classe Frame de l'AWT : les principales différences sont l'utilisation du double buffering qui améliore les rafraichissements et l'utilisation d'un panneau de contenu (contentPane) pour insérer des composants (ils ne sont plus insérer directement au JFrame mais à l'objet contentPane qui lui est associé). Elle représente une fenêtre principale qui possède un titre, une taille modifiable et éventuellement un menu.

La classe possède plusieurs constructeurs :

Constructeur	Rôle
JFrame()
JFrame(String)	Création d'une instance en précisant le titre

Par défaut, la fenêtre créée n'est pas visible. La méthode setVisible() permet de l'afficher.

import javax.swing.*;
public class TestJFrame1 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    f.setVisible(true);
  }
}

La gestion des événements est identique à celle utilisée dans l'AWT depuis le J.D.K. 1.1.

import javax.swing.*;
import java.awt.event.*;
public class swing2 extends JFrame {
   public swing2() {
     super("titre de l'application");
      WindowListener l = new WindowAdapter() {
         public void windowClosing(WindowEvent e){
           System.exit(0);
         }
      };
     addWindowListener(l);
     JButton bouton = new JButton("Mon bouton");
     JPanel panneau = new JPanel();
     panneau.add(bouton);
     setContentPane(panneau);
     setSize(200,100);
     setVisible(true);
   }
   public static void main(String [] args){
      JFrame frame = new swing2();
   }
}

Tous les composants associés à un objet JFrame sont gérer par un objet de la classe JRootPane. Un objet JRootPane contient plusieurs Panes. Tous les composants ajoutés au JFame doivent être ajouté à un Pane du JRootPane et non au JFrame directement. C'est aussi à un de ces Panes qu'il faut associer un layout manager si nécessaire.

Le Pane le plus utilisé est le ContentPane. Le Layout manager par défaut du contentPane est BorderLayout. Il est possible de le changer :

...
f.getContentPane().setLayout(new FlowLayout());
...

import javax.swing.*;
public class TestJFrame2 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JButton b =new JButton("Mon bouton");
    f.getContentPane().add(b);
    f.setVisible(true);
  }
}

Le JRootPane se compose de plusieurs éléments :

glassPane : un JPanel par défaut
layeredPane qui se compose du contentPane (un JPanel par défaut) et du menuBar (un objet de type JMenuBar)

Le glassPane est un JPanel transparent qui se situe au dessus du layeredPane. Le glassPane peut être n'importe quel composant : pour le modifier il faut utiliser la méthode setGlassPane() en fournissant le composant en paramètre.

Le layeredPane regroupe le contentPane et le menuBar.

Le contentPane est par défaut un JPanel opaque dont le gestionnaire de présentation est un BorderLayout. Ce panel peut être remplacé par n'importe quel composant grâce à la méthode setContentPane().

Attention : il ne faut pas utiliser directement la méthode setLayout() d'un objet JFrame sinon une exception est levée.

import javax.swing.*;
import java.awt.*;
public class TestJFrame7 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setLayout(new FlowLayout());
    f.setSize(300,100);
    f.setVisible(true);
  }
}

C:\swing\code>java TestJFrame7
Exception in thread "main" java.lang.Error: Do not use javax.swing.JFrame.setLay
out() use javax.swing.JFrame.getContentPane().setLayout() instead
        at javax.swing.JFrame.createRootPaneException(Unknown Source)
        at javax.swing.JFrame.setLayout(Unknown Source)
        at TestJFrame7.main(TestJFrame7.java:8)

Le menuBar permet d'attacher un menu à la JFrame. Par défaut, le menuBar est vide. La méthode setJMenuBar() permet d'affecter un menu à la JFrame.


import javax.swing.*;
import java.awt.*;
public class TestJFrame6 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JButton b =new JButton("Mon bouton"); 
    f.getContentPane().add(b);
    JMenuBar menuBar = new JMenuBar();
    f.setJMenuBar(menuBar);
    JMenu menu = new JMenu("Fichier");
    menu.add(menuItem);
    menuBar.add(menu);
    f.setVisible(true);
  }
}

13.4.1.1. Le comportement par défaut à la fermeture

Il possible préciser comment un objet JFrame, JInternalFrame, ou Jdialog réagit à sa fermeture grâce à la méthode setDefaultCloseOperation(). Cette méthode attend en paramètre une valeur qui peut être :

Constante	Rôle
WindowConstants.DISPOSE_ON_CLOSE	détruit la fenêtre
WindowConstants.DO_NOTHING_ON_CLOSE	rend le bouton de fermeture inactif
WindowConstants.HIDE_ON_CLOSE	cache la fenêtre

Cette méthode ne permet pas d'associer d'autres traitements. Dans ce cas, il faut intercepter l'évenement et lui associer les traitements.


import javax.swing.*;
public class TestJFrame3 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JButton b =new JButton("Mon bouton"); 
    f.getContentPane().add(b);
    f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    f.setVisible(true);
  }
}

13.4.1.2. La personnalisation de l'icone

La méthode setIconImage() permet de modifier l'icône de la JFrame.

import javax.swing.*;
public class TestJFrame4 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JButton b =new JButton("Mon bouton"); 
    f.getContentPane().add(b);
    f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    ImageIcon image = new ImageIcon("book.gif");
    f.setIconImage(image.getImage());
    f.setVisible(true);
  }
}

Si l'image n'est pas trouvée, alors l'icône est vide. Si l'image est trop grande, elle est redimensionnée.

13.4.1.3. Centrer une JFrame à l'écran

Par défaut, une JFrame est affichée dans le coin supérieur gauche de l'écran. Pour la centrer dans l'écran, il faut procéder comme pour une Frame : déterminer la position de la Frame en fonction de sa dimension et de celle de l'écran et utiliser la méthode setLocation() pour affecter cette position.

import javax.swing.*;
import java.awt.*;
public class TestJFrame5 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JButton b =new JButton("Mon bouton"); 
    f.getContentPane().add(b);
    f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
    f.setLocation(dim.width/2 - f.getWidth()/2, dim.height/2 - f.getHeight()/2);
    f.setVisible(true);
  }
}

13.4.1.4. Les évenements associées à un JFrame

La gestion des évenements associés à un objet JFrame est identique à celle utilisée pour un objet de type Frame de AWT.

import javax.swing.*;
import java.awt.event.*;
public class TestJFrame8 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    f.setVisible(true);
    f.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          System.exit(0);
        }        
      }
    );
  }
}

13.4.2. Les étiquettes : la classe JLabel

Le composant JLabel propose les mêmes fonctionnalités que les intitulés AWT mais ils peuvent en plus contenir des icônes .

Cette classe possède plusieurs constructeurs :

Constructeurs	Rôle
JLabel()	Création d'une instance sans texte ni image
JLabel(Icon)	Création d'une instance en précisant l'image
JLabel(Icon, int)	Création d'une instance en précisant l'image et l'alignement horizontal
JLabel(String)	Création d'une instance en précisant le texte
JLabel(String, Icon, int)	Création d'une instance en précisant le texte, l'image et l'alignement horizontal
JLabel(String, int)	Création d'une instance en précisant le texte et l'alignement horizontal

Le composant JLabel permet d'afficher un texte et/ou une icône en précisant leur alignement. L'icône doit être au format GIF et peut être une animation dans ce format.

import javax.swing.*;
import java.awt.*;
public class TestJLabel1 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(100,200);
    JPanel pannel = new JPanel(); 
    JLabel jLabel1 =new JLabel("Mon texte dans JLabel"); 
    pannel.add(jLabel1);
    ImageIcon icone = new ImageIcon("book.gif");
    JLabel jLabel2 =new JLabel(icone); 
    pannel.add(jLabel2);
    JLabel jLabel3 =new JLabel("Mon texte",icone,SwingConstants.LEFT); 
    pannel.add(jLabel3);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

La classe JLabel définie plusieurs méthodes pour modifier l'apparence du composant :

Méthodes	Rôle
setText()	Permet d'initialiser ou de modifier le texte affiché
setOpaque()	Indiquer si le composant est transparent (paramètre false) ou opaque (true)
setBackground()	Indique la couleur de fond du composant (setOpaque doit être à true)
setFont()	Permet de présicer la police du texte
setForeGround()	Permet de préciser la couleur du texte
setHorizontalAlignment()	Permet de modifier l'alignement horizontal du texte et de l'icône
setVerticalAlignment()	Permet de modifier l'alignement vertical du texte et de l'icône
setHorizontalTextAlignment()	Permet de modifier l'alignement horizontal du texte uniquement
setVerticalTextAlignment()	Permet de modifier l'alignement vertical du texte uniquement Exemple : jLabel.setVerticalTextPosition(SwingConstants.TOP);
setIcon()	Permet d'assigner une icône
setDisabledIcon()	Permet d'assigner une icône dans un état désactivée

L'alignement vertical par défaut d'un JLabel est centré. L'alignement horizontal par défaut est soit à droite si il ne contient que du texte, soit centré si il contient un image avec ou sans texte. Pour modifier cette alignement, il suffit d'utiliser les méthodes ci dessus en utilisant des constantes en paramètres : SwingConstants.LEFT, SwingConstants.CENTER, SwingConstants.RIGHT, SwingConstants.TOP, SwingConstants.BOTTOM

Par défaut, un JLabel est transparent : son fond n'est pas dessiné. Pour le dessiner, il faut utiliser la méthode setOpaque() :

import javax.swing.*;
import java.awt.*;
public class TestJLabel2 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(100,200);
    JPanel pannel = new JPanel(); 
    JLabel jLabel1 =new JLabel("Mon texte dans JLabel 1"); 
    jLabel1.setBackground(Color.red);
    pannel.add(jLabel1);
    JLabel jLabel2 =new JLabel("Mon texte dans JLabel 2"); 
    jLabel2.setBackground(Color.red);
    jLabel2.setOpaque(true);
    pannel.add(jLabel2);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

Dans l'exemple, les 2 JLabel ont le fond rouge demandé par la méthode setBackground(). Seul le deuxième affiche un fond rouge car il est rendu opaque avec la méthode setOpaque().

Il est possible d'associer un raccourci clavier au JLabel qui permet de donner le focus à un autre composant. La méthode setDisplayedMnemonic() permet de définir le raccourci clavier. Celui ci sera activé en utilisant la touche Alt avec le caractère fourni en paramètre. La méthode setLabelFor() permet d'associer le composant fourni en paramètre au raccourci.

import javax.swing.*;
import java.awt.*;
public class TestJLabel3 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel(); 
    JButton bouton = new JButton("saisir");
    pannel.add(bouton);
    JTextField jEdit = new JTextField("votre nom");
    JLabel jLabel1 =new JLabel("Nom : "); 
    jLabel1.setBackground(Color.red);
    jLabel1.setDisplayedMnemonic('n');
    jLabel1.setLabelFor(jEdit);
    pannel.add(jLabel1);
    pannel.add(jEdit);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

Dans l'exemple, à l'ouverture de la fenêtre, le focus est sur le bouton. Un appui sur Alt+'n' donne le focus au champ de saisie.

13.4.3. Les panneaux : la classe Jpanel

La classe JPanel est un conteneur utilisé pour regrouper et organiser des composants grâce à un gestionnaire de présentation (layout manager). Le gestionnaire par défaut d'un JPanel est un objet de la classe FlowLayout.

13.5. Les boutons

Il existe plusieurs boutons définis par Swing.

13.5.1. La classe AbstractButton

C'est une classe abstraite dont hérite les boutons Swing JButton, JMenuItem et JToggleButton.

Cette classe définie de nombreuses méthodes dont les principales sont :

Méthode	Rôle
AddActionListener	Associer un écouteur sur un évenement de type ActionEvent
AddChangeListener	Associer un écouteur sur un évenement de type ChangeEvent
AddItemListener	Associer un écouteur sur un évenement de type ItemEvent
doClick()	Déclencher un clic par programmation
getText()	Texte affiché par le composant
setDisabledIcon()	Associé une icone affichée lorsque le composant à l'état désélectionné
setDisabledSelectedIcon()	Associé une icone affichée lors du passage de la souris sur le composant à l'état désélectionné
setEnabled()	activer/désactiver le composant
setMnemonic()	associer un raccouci clavier
setPressedIcon()	Associé une icone affichée lorsque le composant est préssé
setRolloverIcon()	Associé une icone affichée lors du passage de la souris sur le composant
setRolloverSelectedIcon()	Associé une icone affichée lors du passage de la souris sur le composant à l'état sélectionné
setSelectedIcon()	Associé une icone affichée lorsque le composant à l'état sélectionné
setText()	Mise à jour du texte du composant
isSelected()	Indique si le composant est dans l'état sélectionné
setSelected()	Mise à jour de l'état selectionné du composant

Tous les boutons peuvent afficher du texte et/ou une image.

Il est possible de préciser une image différente lors du passage de la souris sur le composant et lors de l'enfoncement du bouton : dans ce cas, il faut créer trois images pour chacun des états (normal, enfoncé et survolé). L'image normale est associée au bouton grace au constructeur, l'image enfoncée grâce à la méthode setPressedIcon() et l'image lors d'un survole grâce à la méthode setRolloverIcon(). Il suffit enfin d'appeler la méthode setRolloverEnable() avec en paramètre la valeur true.

import javax.swing.*;
import java.awt.event.*;
public class swing4 extends JFrame {
   public swing4() {
     super("titre de l'application");
     WindowListener l = new WindowAdapter() {
       public void windowClosing(WindowEvent e){
         System.exit(0);
       }
     };
     addWindowListener(l);
     ImageIcon imageNormale = new ImageIcon("arrow.gif");
     ImageIcon imagePassage =  new ImageIcon("arrowr.gif");
     ImageIcon imageEnfoncee = new ImageIcon("arrowy.gif");
     JButton bouton = new JButton("Mon bouton",imageNormale);
     bouton.setPressedIcon(imageEnfoncee);
     bouton.setRolloverIcon(imagePassage);
     bouton.setRolloverEnabled(true);
     getContentPane().add(bouton, "Center");
     JPanel panneau = new JPanel();
     panneau.add(bouton);
     setContentPane(panneau);
     setSize(200,100);
     setVisible(true);
   }
   public static void main(String [] args){
      JFrame frame = new swing4();
   }
}

Un bouton peut recevoir des évenements de type ActionEvents (le bouton a été activé), ChangeEvents, et ItemEvents.


import javax.swing.*;
import java.awt.event.*;
public class TestJButton3 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel(); 
    JButton bouton1 = new JButton("Bouton1");
    bouton1.addActionListener( new ActionListener() {
       public void actionPerformed(ActionEvent e) {
         System.exit(0);
       }
    }
    );
    pannel.add(bouton1);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

Pour de plus amplements informations sur la gestion des événements, voir le chapitre correspondant.

13.5.2. La classe JButton : les boutons

JButton est un composant qui représente un bouton : il peut contenir un texte et/ou une icône.

Il ne gère pas d'état.

Les constructeurs sont :

Constructeur	Rôle
JButton()
JButton(String)	préciser le texte du bouton
JButton(Icon)	préciser une icône
JButton(String, Icon)	préciser un texte et une icone

Il ne gère pas d'état. Toutes les indications concernant le contenu du composant JLabel sont valables pour le composant JButton.

import javax.swing.*;
import java.awt.event.*;
public class swing3 extends JFrame {
   public swing3() {
      super("titre de l'application");
      WindowListener l = new WindowAdapter() {
         public void windowClosing(WindowEvent e){
            System.exit(0);
         }
      };
      addWindowListener(l);
      ImageIcon img = new ImageIcon("tips.gif");
      JButton bouton = new JButton("Mon bouton",img);
      JPanel panneau = new JPanel();
      panneau.add(bouton);
      setContentPane(panneau);
      setSize(200,100);
      setVisible(true);
  }
  public static void main(String [] args){
      JFrame frame = new swing3();
  }
}

L'image gif peut être une animation.

Dans un conteneur de type JRootPane, il est possible de définir un bouton par défaut grace à sa méthode setDefaultButton().


import javax.swing.*;
import java.awt.*;
public class TestJButton2 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel(); 
    JButton bouton1 = new JButton("Bouton 1");
    pannel.add(bouton1);
    JButton bouton2 = new JButton("Bouton 2");
    pannel.add(bouton2);
    JButton bouton3 = new JButton("Bouton 3");
    pannel.add(bouton3);
    f.getContentPane().add(pannel);
    f.getRootPane().setDefaultButton(bouton3);
    f.setVisible(true);
  }
}

Le bouton par défaut est activé par un appui sur la touche Entrée alors que le bouton actif est activé par un appui sur la barre d'espace.

La méthode isDefaultButton() de JButton permet de savoir si le composant est le bouton par défaut.

13.5.3. La classe JToggleButton

Cette classe définit un bouton à deux états : c'est la classe mère des composants JCheckBox et JRadioButton.

La méthode setSelected() héritée de AbstractButton permet de mettre à jour l'état du bouton. La méthode isSelected() permet de connaître cet état.

13.5.4. La classe ButtonGroup

La classe ButtonGroup permet de gérer un ensemble de boutons en garantissant qu'un seul bouton du groupe sera sélectionné.

Pour utiliser la classe ButtonGroup, il suffit d'instancier un objet et d'ajouter des boutons (objet héritant de la classe AbstractButton grâce à la méthode add(). Il est préférable d'utiliser des objets de la classe JToggleButton ou d'une de ces classes filles car elles sont capables de gérer leurs états.

import javax.swing.*;
public class TestGroupButton1 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel();
    ButtonGroup groupe = new ButtonGroup();
    JRadioButton bouton1 = new JRadioButton("Bouton 1");
    groupe.add(bouton1);
    pannel.add(bouton1);
    JRadioButton bouton2 = new JRadioButton("Bouton 2");
    groupe.add(bouton2);
    pannel.add(bouton2);
    JRadioButton bouton3 = new JRadioButton("Bouton 3");
    groupe.add(bouton3);
    pannel.add(bouton3);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

13.5.5. Les cases à cocher : la classe JCheckBox

Les constructeurs sont les suivants :

Constructeur	Rôle
JCheckBox(String)	précise l'intitulé
JCheckBox(String, boolean)	précise l'intitulé et l'état
JCheckBox(Icon)	précise une icône comme intitulé
JCheckBox(Icon, boolean)	précise une icône comme intitulé et l'état
JCheckBox(String, Icon)	précise un texte et une icône comme intitulé
JCheckBox(String, Icon, boolean)	précise un texte et une icône comme intitulé et l'état

Un groupe de cases à cocher peut être défini avec la classe ButtonGroup. Dans ce cas, un seul composant du groupe peut être sélectionné. Pour l'utiliser, il faut créer un objet de la classe ButtonGroup et utiliser la méthode add() pour ajouter un composant au groupe.

import javax.swing.*;
public class TestJCheckBox1 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel();
    JCheckBox bouton1 = new JCheckBox("Bouton 1");
    pannel.add(bouton1);
    JCheckBox bouton2 = new JCheckBox("Bouton 2");
    pannel.add(bouton2);
    JCheckBox bouton3 = new JCheckBox("Bouton 3");
    pannel.add(bouton3);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

13.5.6. Les boutons radio : la classe JRadioButton

Les constructeurs sont les même que ceux de la classe JCheckBox.

import javax.swing.*;
public class TestJRadioButton1 {
  public static void main(String argv[]) {
    JFrame f = new JFrame("ma fenetre");
    f.setSize(300,100);
    JPanel pannel = new JPanel();
    JRadioButton bouton1 = new JRadioButton("Bouton 1");
    pannel.add(bouton1);
    JRadioButton bouton2 = new JRadioButton("Bouton 2");
    pannel.add(bouton2);
    JRadioButton bouton3 = new JRadioButton("Bouton 3");
    pannel.add(bouton3);
    f.getContentPane().add(pannel);
    f.setVisible(true);
  }
}

Pour regrouper plusieurs boutons radio, il faut utiliser la classe CheckboxGroup

La suite de ce chapitre sera développée dans une version future de ce document

[ Précédent ] [ Sommaire ] [ Suivant ] [ Télécharger ]