Vous êtes sur la page 1sur 248

La programmation

graphique et
événementielle en

Rajae El Ouazzani

2014-2015
La programmation graphique et
événementielle en Java
[1]

2014-2015 2
Présentation
 Swing est la boîte à outils d'interface utilisateur de Java. Il a été développé
durant l'existence de Java 1.1 et fait désormais partie des API (Automates
Programmables Industrielles) centrales de Java 1.2 et supérieure.

 Swing, via son paquetage javax.swing (ainsi que ses nombreux sous-
paquetages), fournit des classes pour représenter des éléments d'interface
comme les fenêtres, des boutons, des boîtes combo, des arborescences, des
grilles et des menus - toute chose nécessaire à la construction d'une
interface utilisateur dans une application Java.

 Swing fait partie d'une collection plus vaste de logiciels baptisée JFC (Java
Foundation Classes). JFC est la partie la plus volumineuse et la plus
compliquée de la plate-forme Standard Java.

2014-2015 3
Plan de la partie Programmation graphique
 Section 1: Introduction
 Section 2: Les conteneurs (JFrame et JPanel)
 Section 3: Le composant bouton (JButton)
 Section 4: Les gestionnaires de placement (Layout)
 Section 5: Les étiquettes (JLabel)
 Section 6: Les images (ImageIcon)
 Section 7: Les composants texte (JTextComponent,
JTextField, JTextArea, JPasswordField, JFormattedTextField,
JEditorPane)

2014-2015 4
Section 1: Introduction

2014-2015 5
Abstract Window Toolkit (AWT)
 Pour comprendre Swing, il est utile de comprendre son prédécesseur
AWT (Abstract Window Toolkit) issu du paquetage java.awt.

 AWT est une abstraction. Il est portable; ses fonctionnalités sont les
mêmes pour toutes les implémentations Java. Bien que les gens
s'attendent généralement à ce que leur applications aient un look-
and-feel cohérent, il est souvent différent d'une plateforme à l'autre.
C'est pourquoi, AWT a été conçu pour fonctionner de la même
façon sur toutes les plate-formes, avec l'aspect du système natif.

2014-2015 6
Suite
 AWT utilise des boîtes à outils interchangeables qui interagissent
avec le système de fenêtrage de l'hôte pour afficher les composants
de l'interface utilisateur.

 Les éléments d'interface utilisateur, ou composants, sont de simples


classes issues du paquetage java.awt. Il y’a la classe Frame (cadre de
la fenêtre), la classe Button (bouton), la classe TextField (zone de
saisie), etc.

 Il sera préférable d’utiliser l'interface utilisateur Swing. Toutefois, on


va utiliser certains des éléments d'AWT comme la classe Color et la
gestion des événements, ainsi que quelques d’autres éléments.
2014-2015 7
Les composants du paquetage java.awt

8
L'interface utilisateur Swing
 Swing suit une approche fondamentalement différente. Les composants
de Swing sont implémentés directement dans Java, càd quelle que soit la
plateforme utilisée, un bouton Swing a toujours la même apparence.

 Les composants Swing sont plus souples et peuvent être complétés et


modifiés dans les applications. Par ailleurs, Swing propose un ensemble
d'éléments d'interface plus étendu et pratique.

 La plupart des classes de composant Swing commencent par la lettre J :


JButton, JFrame, etc. (Button et Frame en AWT).

 Pour retrouver ces composants Swing, il faut importer le paquetage


javax.swing.
2014-2015 9
De AWT à Swing

 JFrame hérite de
Frame.
 JButton, JLabel,
JTextField, JMenu,
etc. héritent tous de
la classe de base
JComponent qui fait
parti de Swing.
 JComponent hérite
indirectement de
Component qui est
un élément de AWT.

2014-2015 10
Construction d'interface utilisateur
 La manipulation des composants d'une interface utilisateur est
facile avec Swing.

 Il y’a des éléments préfabriqués (bouton, zone de texte, etc.),


facile à assembler et à disposer dans des conteneurs afin de
construire des placements complexes.

 Ces composants simples sont des briques utilisé dans la création


de nouveaux types de gadgets d'interface complètement
portables et réutilisables.

2014-2015 11
Les composants
 Un composant est l'objet fondamental d'une interface utilisateur
sous Java.
 Les fenêtres, les boutons, les cases à cocher, les barres de
défilement, les listes, les menus, les champs de saisie, etc, sont tous
des composants.

 Pour être utilisé, un composant doit généralement être placé dans


un conteneur. Les objets conteneurs regroupent des composants, les
disposent pour les afficher dans un gestionnaire de placement et les
associent à un périphérique d'affichage particulier.
Conteneur

Composant 1 Composant 2
12
De AWT à Swing

Remarque:
•JComponent héritant de
Container, possède à la fois les
capacités d'un composant et d'un
conteneur.
• La classe mère de Component est
Object.
2014-2015 13
Suite
Tous les composants Swing,
sauf pour les conteneurs
fenêtre, dérivent de la classe
abstraite
javax.swing.JComponent.

Par exemple, la classe JButton


est une classe fille de la classe
AbstractButton, elle-même
classe fille de la classe
JComponent.

2014-2015 14
Il y’a des classes similaires
Suite dans les deux hiérarchies, par
exemple, Button et JButton.

Mais Swing est beaucoup


plus qu'un simple
remplacement de AWT - il
contient des composants
sophistiqués, comme List et
JList ainsi qu'une véritable
implémentation du
paradigme MVC (Modèle-
Vue-Contrôleur). C’est un
modèle destiné à répondre
aux besoins des applications
interactives en séparant les
problématiques liées aux
différents composants au sein
de leur architecture respective
2014-2015 [6].
Section 2: Les conteneurs

2014-2015 16
Les conteneurs
 Un conteneur est un
composant qui contient
et gère d'autres
composants.

 Des objets JComponent


peuvent être des
conteneurs, car
JComponent descend de
Container.

2014-2015 17
Suite
 Les 3 types de conteneurs les plus utilisés sont :
 JFrame: c’est une fenêtre de niveau supérieur de votre écran. Elle
hérite de Window, assez semblable mais sans bordure.
 JPanel: c’est un conteneur générique, il sert à regrouper des
composants à l'intérieur de JFrame et d'autres JPanel.
 et JApplet: c’est une sorte de conteneur de classe servant de base
aux processus exécutés dans un navigateur Web. Comme tout
JComponent, un JApplet peut contenir d'autres composants
d'interface utilisateur.

2014-2015 18
Remarques
 On peut utiliser la classe JComponent directement, comme un
JPanel, pour maintenir des composants dans un autre conteneur.

 A l'exception de JFrame et de JWindow, tous les composants et


conteneurs Swing sont légers (écrits en Java).

 On ne doit pas ajouter directement des composants à des


composants spécialisés comme les boutons ou les listes.

2014-2015 19
Fenêtres et cadres
 Les fenêtres (JWindow) et les cadres (JFrame) sont les conteneurs de
plus haut niveau des composants Java.

 JWindow n'est rien d'autre qu'un plein écran graphique d'affichage


dans le système de fenêtrage. Elles conviennent surtout pour faire
surgir des écrans et des fenêtres popup.

 De son côté, JFrame est une classe fille de JWindow, équipée d'une
bordure et pouvant contenir une barre de menu. Il est également
possible de déplacer un cadre sur l'écran et de le redimensionner, à
l'aide des contrôles habituels de l'environnement de fenêtrage.

2014-2015 20
Exemple
import javax.swing.*;
public class Exemple {
public static void main(String[] args) {
JFrame cadre = new JFrame("Ma première fenêtre Java");/* Le
constructeur de JFrame demande le titre de la fenêtre */
cadre.setSize(400, 100); // La taille de JFrame sur le bureau
cadre.setLocation(150,100); // position de JFrame sur le bureau

JWindow fenêtre = new JWindow();// JWindow n’a pas de titre


fenêtre.setSize(400, 100); // La taille de JWindow sur le bureau
fenêtre.setLocation(500, 100); // La position de JWindow

cadre.setVisible(true); // Affichage des conteneurs sur l'écran


fenêtre.setVisible(true);
}
}
2014-2015 21
Résultat
 Le cadre créé:

 La fenêtre créée:

2014-2015 22
Remarques
 Le constructeur de JFrame peut prendre un argument String indiquant
le titre affiché dans la barre de titre. Il est également possible de créer
un JFrame sans titre, puis d'appeler ensuite la méthode setTitle() pour
en fournir un ultérieurement.

 JWindow ne possède pas de barre de titre, donc le constructeur de


JWindow n’a pas d'arguments.

 setVisible(true) affiche les conteneurs sur l'écran. JFrame se cache


lorsqu’on clique dessus, en appelant la méthode setVisible(false).

2014-2015 23
 Il est toutefois impossible de fermer un JWindow dans l'application.
Pour mettre fin à l'exécution de l'application Fenêtres, il faut saisir Crtl-C
ou la touche destinée à tuer un processus sur votre machine. Du coup,
JWindow sera plutôt utilisé par un autre JFrame et sera très rarement la
fenêtre principale d'une application.

 Les cadres (JFrame) sont des exemples de conteneurs. Ils peuvent


contenir d'autres composants d'interface tels que les boutons et des
champs de texte. De toute façon, tous les autres composants et
conteneurs doivent, à un certain niveau, se trouver dans un JWindow ou
un JFrame.

2014-2015 24
Traitement des cadres: JFrame

2014-2015 25
Création d'un cadre visible avec une fermeture direct de
l'application

2014-2015 26
Code
import javax.swing.JFrame;
public class Exemple extends JFrame{
public Exemple(String titre) {
super(titre); /* appel au constructeur de la classe
JFrame, il accepte un paramètre de type String pour le
titre de la fenêtre. */
setSize(300, 200);
setLocation(100, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Exemple("Première fenêtre");
}
}
2014-2015 27
Autre écriture
import javax.swing.JFrame;
public class Exemple extends JFrame{
public Exemple(String titre) {
super(titre);
setSize(300, 200);
setLocation(100, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE); Ou
setVisible(true); import javax.swing.JFrame;
}
public class Exemple extends JFrame {
public static void main(String[]
args) { public Exemple(){
new Exemple("Première fenêtre");
setTitle("Première fenêtre");
} /* positionne et donne les dimensions en
} une seule fois. */
setBounds(100, 100, 300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Exemple();
}
} 28
Quelques méthodes utiles
 setTitle(): permet d’attribuer un titre à la fenêtre.
 setSize(): Par défaut, un cadre a la taille 0x0 pixels. La méthode précise la
taille requise.
 setLocation(): cette méthode de la classe Component peut être utilisée pour
un JFrame ou un JWindow pour définir sa position à l'écran. Les
coordonnées x et y sont relatives à l'origine de l'écran (le coin supérieur
gauche). Attention, l'axe des abscisses est orientée vers la droite, celui des
ordonnées vers le bas.

2014-2015 29
 setDefaultCloseOperation(): indique ce que doit se passer lorsque
l'utilisateur ferme ce cadre. On peut imposer le comportement qu’on
souhaite lors de la fermeture de la fenêtre, en appelant cette méthode avec
l'un des arguments suivants :
 DO_NOTHING_ON_CLOSE: ne rien faire.
 DISPOSE_ON_CLOSE: détruire l'objet fenêtre.
 EXIT_ON_CLOSE: terminer l'application.
 HIDE_ON_CLOSE: cacher la fenêtre (comportement par défaut).

2014-2015 30
Position et réglage du cadre de la fenêtre

 La classe JFrame ne fournit que peu de méthodes capables de


modifier l'aspect d'un cadre. Cependant, grâce à l'héritage, les
diverses superclasses de JFrame proposent la plupart des méthodes
permettant d'agir sur la taille et la position d'un cadre ainsi que
quelques petits ajouts intéressants.

 C'est généralement dans la classe Component (ancêtre de tous les


objets d'interface utilisateur graphique) ou dans la classe Window
(superclasse du parent de la classe Frame) que l'on recherche les
méthodes permettant de modifier la taille et la position des cadres.

2014-2015 31
2014-2015 32
Méthodes de la classe java.awt.Component
Méthodes Descriptions
boolean isVisible() Renvoie true si le composant est visible. Par défaut,
les composants sont visibles, à l'exception des
composants de haut niveau tels que JFrame.

void setVisible(boolean visible) Affiche ou cache le composant, selon la valeur


booléenne proposée (respectivement true ou false).
boolean isShowing() Vérifie que le composant s'affiche à l'écran. Pour cela,
le composant doit être visible et son éventuel
conteneur doit être également affiché.
boolean isEnabled() et Obtient ou définit l'activité du composant. Un
void setEnabled(boolean composant activé peut recevoir le focus du clavier.
activation) Les composants sont initialement activés.

2014-2015 33
Méthodes Descriptions
Point getLocation(), Obtient ou définit la position actuelle du composant
Point getLocationOnScreen(), par rapport au composant parent.
void setLocation(Point p), getLocationOnScreen() précise les coordonnées par
void setLocation(int x, int y) rapport à l'écran.
Dimension getSize(), Obtient ou définit la taille actuelle du composant. Un
gestionnaire de placement peut modifier la taille d'un
void setSize(int larg, int haut) composant même après que vous l'avez définie. Pour
changer la taille qu'un composant veut avoir, utilisez
alors la méthode setPreferedSize(). D'autres méthodes
de Component permettent de définir son
emplacement, mais cette tâche est normalement
attribuée à un gestionnaire de placement.
Rectangle getBounds(), Obtient ou définit à la fois la position et la taille
void setBounds(Rectangle actuelle du composant.
zonePréférée), Lorsque le composant doit être automatiquement
void setBounds(int x, int y, int redimensionnné, cette dernière méthode est
larg, int long): systématiquement appelée.
34
Méthodes de la classe java.awt.Window
 En plus des méthodes de la classe Component de laquelle elle hérite,
la classe Window a les méthodes suivantes:

Méthodes Descriptions
void toFront() Affiche cette fenêtre par-dessus toutes les autres.
void toBack() Place cette fenêtre au-dessous de la pile des fenêtres du bureau
et réorganise les autres fenêtres visibles.

2014-2015 35
Méthodes de la classe java.awt.Frame
 En plus des méthodes de la classe Window de laquelle elle hérite, la classe Frame a
les méthodes suivantes:
Méthodes Descriptions
void setResizable( Détermine si l'utilisateur peut modifier la taille du cadre.
boolean visible) setResizable(false): la taille du cadre ne change plus durant toute sa
durée de vie.
void setTitle(String titre) Affiche la chaîne titre sur la barre de titre du cadre.
void setIconImage( Spécifie l'icône de l'application qui est alors visible sur le bord supérieur
Image icône) gauche de la fenêtre ou dans la barre de tâche lorsque la fenêtre est
réduite sous forme d'icône.
int getExtendedState() Récupère ou définit l'état de la fenêtre. Voici les états possibles :
et -- normal : Frame.NORMAL
void setExtendedState( -- icônifié : Frame.ICONIFIED
int état) -- maximum en horizontal : Frame.MAXIMIZED_HORIZ
-- maximum en vertical : Frame.MAXIMIZED_VERT
-- plein écran : Frame.MAXIMIZED_BOTH
setExtendedState(Frame.MAXIMIZED_BOTH): fenêtre plein écran
Méthodes de la classe java.awt.Toolkit
 La classe java.awt.Toolkit dérive de la classe mère java.lang.Object et elle a
les méthodes suivantes:

Méthodes Descriptions
static Toolkit getDefaultToolkit() Renvoie la boîte à outils par défaut.
Dimension getScreenSize() Renvoie la taille de l'écran.
Image getImage(String fichierImage) Charge une image à partir du nom du
et fichier spécifié en argument ou à partir de
Image getImage(URL url) son URL.

2014-2015 37
Exemple
import java.awt.*;
import javax.swing.JFrame;
public class Exemple extends JFrame{
public Exemple() {
setTitle("Cadre centré à l'écran"); Remarque:
Toolkit kit = Toolkit.getDefaultToolkit(); Les méthodes getScreenSize()
Dimension dimensionEcran = et getImage() de la classe
kit.getScreenSize(); Toolkit sont des méthodes
int w = dimensionEcran.width; non statiques.
int h = dimensionEcran.height; Vous devez donc créer au
setBounds((w-300)/2, (h-200)/2,300, 200); préalable un objet
setDefaultCloseOperation(EXIT_ON_CLOSE); représentant la boîte à outil
setIconImage(kit.getImage("icone.png")); en utilisant la méthode
setResizable(false); statique getDefaultToolkit().
setVisible(true);
}
public static void main(String[] args) {
new Exemple() ; }
} 2014-2015 38
Résultat

2014-2015 39
Traitement de JPanel
[2]

2014-2015 40
Présentation
 Un JPanel est un composant de type conteneur.

 Il accueille d'autres objets de même type ou des objets de type


composant (boutons, cases à cocher, etc.).

2014-2015 41
Exemple
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Exemple extends JFrame{
public Exemple(){
this.setTitle("Mon cadre");
this.setSize(400, 100);
//On demande à notre objet de se positionner au centre.
this.setLocationRelativeTo(null);
JPanel pan = new JPanel(); //Instanciation d'un objet JPanel
pan.setBackground(Color.ORANGE); /* définition de la couleur de
fond. SetBackground fonctionne sur un panel */
//On ajoute pan à Jframe.
this.setContentPane(pan); // équivalent à this.add(pan)
this.setVisible(true);
}
public static void main(String[] args) {
new Exemple() ; }
} 42
Section 3: Le composant bouton
(JButton)

2014-2015 43
Classe JButton
La classe JButton est
issue du package
javax.swing.

2014-2015 44
Exemple
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Exemple extends JFrame{
private JPanel pan = new JPanel();
private JButton bouton = new JButton("OK");
public Exemple(){
this.setTitle("Mon bouton");
this.setSize(300, 150);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// l’utilisation de Jframe avant EXIT_ON_CLOSE est facultative
this.setLocationRelativeTo(null);
pan.add(bouton); //Ajout du bouton au pan
this.add(pan); //Ajout du pan au cadre
this.setVisible(true);
}
public static void main(String[] args) {
new Exemple() ; }
}
2014-2015 45
Explication
 Le bouton est centré sur le conteneur. Par défaut, JPanel gère la mise en page.

cadre
pan
bouton

46
Autre exemple
 Dans cet exemple, on utilise le pane de JFrame. Le bouton occupe l’espace
total de la fenêtre.

cadre pan du cadre

bouton

2014-2015 47
Code
import javax.swing.JButton;
import javax.swing.JFrame;
public class Exemple extends JFrame{
private JButton bouton = new JButton("Mon bouton");
public Exemple(){
this.setTitle("Bouton");
this.setSize(300, 150);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
//On ajoute le bouton au content pane de JFrame
this.getContentPane().add(bouton); //équivalent à: add(bouton)
this.setVisible(true);
}
public static void main(String[] args) {
new Exemple() ;
}
}

48
Section 4: Gestionnaires de
placement (Layout)

2014-2015 49
Présentation
 Un gestionnaire de placement est un objet qui contrôle le
placement et le dimensionnement des composants situés à
l'intérieur de la zone d'affichage d'un conteneur. Il ressemble au
gestionnaire de fenêtres d'un système d'affichage.

 Chaque conteneur possède un gestionnaire de placement par


défaut, mais il est possible d'en installer un nouveau en appelant
sa méthode setLayout().

 Swing possède plusieurs gestionnaires de placement qui


implémentent des modèles de disposition courants:

2014-2015 50
2014-2015 51
FlowLayout
 C’est le gestionnaire de placement par défaut d'un JPanel.

 Il place les objets sous leur taille préférée de gauche à droite et de


haut en bas.

2014-2015 52
import javax.swing.*;
public class Fenêtre extends JFrame {
private JButton b1= new JButton("bouton1");
private JButton b2= new JButton("bouton2");
private JButton b3= new JButton("bouton3");
private JButton b4= new JButton("bouton4");
private JButton b5= new JButton("bouton5");
private JPanel panneau = new JPanel();
public Fenêtre() {
setTitle("FlowLayout"); setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
panneau.add(b1); panneau.add(b2); panneau.add(b3);
panneau.add(b4); panneau.add(b5);
add(panneau);
setVisible(true);
}
public static void main(String[] args) {
new Fenêtre();
}
}
2014-2015 53
BorderLayout
 C’est le gestionnaire de placement par défaut de JFrame.

 Il place les objets à des emplacements particuliers du cadre


comme: Nord, Sud, Est, Ouest et Centre :

2014-2015 54
import java.awt.BorderLayout;
import javax.swing.*;
public class Exemple extends JFrame{
private JButton nord= new JButton("Nord");
private JButton ouest= new JButton("Ouest");
private JButton sud= new JButton("Sud");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
public Exemple() {
setTitle("BorderLayout"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
add(nord, BorderLayout.NORTH); add(ouest, BorderLayout.WEST);
add(sud, BorderLayout.SOUTH); add(centre, BorderLayout.CENTER);
add(est, BorderLayout.EAST);
setVisible(true);
}
public static void main(String[] args) {
new Exemple();
}
} 55
 On utilise dans cet exemple le pane de JFrame:
import java.awt.BorderLayout; import javax.swing.*;
public class Exemple extends JFrame{
private JButton b1=new JButton("Centre");
public Exemple(){
this.setTitle("BorderLayout"); this.setSize(300, 250);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLayout(new BorderLayout()); // le layout à utiliser
//On ajoute les boutons au content pane de la Jframe
this.getContentPane().add(b1, BorderLayout.CENTER);
this.getContentPane().add(new JButton("Nord"), BorderLayout.NORTH);
this.getContentPane().add(new JButton("Sud"), BorderLayout.SOUTH);
this.getContentPane().add(new JButton("Ouest"), BorderLayout.WEST);
this.getContentPane().add(new JButton("Est"), BorderLayout.EAST);
this.setVisible(true);
}
public static void main(String[] args) {
new Exemple(); }
}
Remarque: This fait référence à l’objet courant et le prog fonctionne aussi si on l’enlève.
56
GridLayout
 Il est possible de changer de gestionnaire de placement par
défaut et d'imposer celui qui vous convient.

 Dans cet exemple, on choisit le gestionnaire GridLayout:

2014-2015 57
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
public class Exemple extends JFrame{
public Exemple (){
this.setTitle("GridLayout"); this.setSize(300, 250);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//On utilise le GridLayout sur le content pane
this.setLayout(new GridLayout(3, 2)); // 3 lignes et 2 colonnes
//On ajoute le bouton au content pane de JFrame
this.getContentPane().add(new JButton("1"));//ou add(new JButton("1"))
this.getContentPane().add(new JButton("2"));
this.getContentPane().add(new JButton("3"));
this.getContentPane().add(new JButton("4"));
this.getContentPane().add(new JButton("5"));
this.setVisible(true);
}
public static void main(String[] args) { new Exemple (); }
}
2014-2015 58
Remarques
 L'idéal est de combiner l'ensemble de
ces gestionnaires au travers de
panneaux intermédiaires (JPanel) afin
d'obtenir l'apparence désirée :

2014-2015 59
Solution
 Au début, on utilise un pan avec BorderLayout avec les bordures
Centre, Est et Sud comme illustré sur la figure suivante:
import java.awt.BorderLayout;
import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud= new JButton("Sud");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JPanel pan1 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.add(sud, BorderLayout.SOUTH);
pan1.add(centre, BorderLayout.CENTER);
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
setVisible(true);
}
public static void main(String[] args) {
new ExempleLayouts();
} 2014-2015 60
Solution
 Après, on ajoute un autre pan BorderLayout avec les bordures Nord,
Centre et Sud2 et on le place au centre du premier pan:

2014-2015 61
Solution
import java.awt.BorderLayout; import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud1= new JButton("Sud1");
private JButton sud2= new JButton("Sud2");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JButton nord= new JButton("Nord");
private JPanel pan1 = new JPanel();
private JPanel pan2 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);// on ajoute pan 2 au centre de pan1
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
pan2.setLayout(new BorderLayout());
pan2.add(nord, BorderLayout.NORTH);
pan2.add(centre, BorderLayout.CENTER);
pan2.add(sud2, BorderLayout.SOUTH);
setVisible(true);
} 2014-2015 62
}
Suite
 Après, on ajoute un autre pan GridLayout avec 5 lignes et 1
colonne et on le place au Nord du deuxième pan:

2014-2015 63
import java.awt.*; import javax.swing.*;
public class ExempleLayouts extends JFrame{
//le début reste inchangé
private JPanel pan3 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
pan2.setLayout(new BorderLayout());
pan2.add(pan3, BorderLayout.NORTH); //on ajoute pan3 au nord de pan2
pan2.add(centre, BorderLayout.CENTER);
pan2.add(sud2, BorderLayout.SOUTH);
pan3.setLayout(new GridLayout(5,1));
pan3.add(new JButton("Nom1")); pan3.add(new JButton("Nom2"));
pan3.add(new JButton("Prenom1"));pan3.add(new JButton("Prenom2"));
pan3.add(new JButton("Adresse"));
setVisible(true);
}
}

2014-2015 64
Suite
 Après, on ajoute un autre pan4 de type GridLayout avec 9 lignes
et 1 colonne et on le place à l’est de pan1:

2014-2015 65
import java.awt.*; import javax.swing.*;
public class ExempleLayouts extends JFrame{
//on ne change rien ici
private JPanel pan4 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);
pan1.add(pan4, BorderLayout.EAST); //on ajoute pan 4à l’Est de pan1
this.add(pan1);
//les codes de pan2 et pan3 reste inchangé
pan4.setLayout(new GridLayout(9,1));
pan4.add(new JButton("Tennis"));
pan4.add(new JButton("Squash"));
pan4.add(new JButton("Natation"));
pan4.add(new JButton("Athlétisme"));
pan4.add(new JButton("Randonnée"));
pan4.add(new JButton("Foot"));
pan4.add(new JButton("Basket"));
pan4.add(new JButton("Volley"));
pan4.add(new JButton("Pelanque"));
setVisible(true);
}
} 2014-2015 66
Suite
 Après, on ajoute deux autres pan: pan5 et pan6 de type
FlowLayout et on les place au sud de pan2 et pan1
respectivement:

2014-2015 67
 Programme complet:
import java.awt.*;
import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud1= new JButton("Sud1");
private JButton sud2= new JButton("Sud2");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JButton nord= new JButton("Nord");
private JPanel pan1 = new JPanel();
private JPanel pan2 = new JPanel();
private JPanel pan3 = new JPanel();
private JPanel pan4 = new JPanel();
private JPanel pan5 = new JPanel();
private JPanel pan6 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(pan6, BorderLayout.SOUTH);// ajouter pan6 au sud de pan1
pan1.add(pan2);
pan1.add(pan4, BorderLayout.EAST);
this.add(pan1);
2014-2015 68
pan2.setLayout(new BorderLayout());
pan2.add(pan3, BorderLayout.NORTH);
pan2.add(centre, BorderLayout.CENTER);
pan2.add(pan5, BorderLayout.SOUTH); // ajouter pan5 au sud de pan2
pan3.setLayout(new GridLayout(5,1));
pan3.add(new JButton("Nom1"));
pan3.add(new JButton("Nom2"));
pan3.add(new JButton("Prenom1"));
pan3.add(new JButton("Prenom2"));
pan3.add(new JButton("Adresse"));
pan4.setLayout(new GridLayout(9,1));
pan4.add(new JButton("Tennis"));
pan4.add(new JButton("Squash"));
pan4.add(new JButton("Natation"));
pan4.add(new JButton("Athlétisme"));
pan4.add(new JButton("Randonnée"));
pan4.add(new JButton("Foot"));
pan4.add(new JButton("Basket"));
pan4.add(new JButton("Volley"));
pan4.add(new JButton("Pelanque"));

2014-2015 69
pan5.setLayout(new FlowLayout());
pan5.add(new JButton("Sexe"));
pan5.add(new JButton("Homme"));
pan5.add(new JButton("Femme"));
pan6.setLayout(new FlowLayout());
pan6.add(new JButton("OK"));
pan6.add(new JButton("Annuler"));
setVisible(true);
}
public static void main(String[] args) {
new ExempleLayouts();
}
}

2014-2015 70
Section 5: Les étiquettes (JLabel)

2014-2015 71
Présentation [3]
 Le composant JLabel permet d'afficher un texte (libellé), une icône
(image) ou les deux à la fois.
 Le texte du composant JLabel n'est pas éditable par l'utilisateur.

Méthodes Description
Créer une instance JLabel, l’initialiser pour avoir
JLabel(Icon)
text/image/alignment spécifiés. L’argument int spécifie
JLabel(Icon, int)
l’alignment horizontal du contenu du label. L’ alignment
JLabel(String)
horizontal doit être un des constants définies dans l’interface
JLabel(String, Icon,
SwingConstants (que JLabel implemente): LEFT, CENTER,
int)
RIGHT, LEADING, or TRAILING. Pour une localisation
JLabel(String, int)
facile, il est recommandé d’utiliser LEADING et TRAILING, à
JLabel()
la place de LEFT et RIGHT.

72
Suite
 La création d'icône fait appel à la classe ImageIcon qui possède un
constructeur permettant de lire l'icône à partir d'un fichier au format
GIF (y compris les images animées GIF89A) ou JPEG ou PNG.

 Exemples:
JLabel lNom = new JLabel("Nom");
Icon image1 = new ImageIcon("H:/pictures/image1.gif");
JLabel lImage = new JLabel(image1);
JLabel lCombi = new JLabel("Texte", image1, JLabel.CENTER);

2014-2015 73
Méthodes Description
void setText(String)
Attribuer or retourner le texte dans le label.
String getText()
void setIcon(Icon)
Attribuer or retourner l’image dans le label.
Icon getIcon()
void setDisplayedMnemonic(char) Attribuer or retourner la letter qui joue le rôle d’une
char getDisplayedMnemonic() alternative au clavier.

void setLabelFor(Component) Attribuer or retourner le composant (un champ texte


Component getLabelFor() par exemple) décrit par le label.
Attribuer or retourner a hint as to which character in
the text should be decorated to represent the
mnemonic. This is useful when you have two instances
void setDisplayedMnemonicIndex(int) of the same character and wish to decorate the second
int getDisplayedMnemonicIndex() instance. For example, setDisplayedMnemonicIndex(5)
decorates the character that is at position 5 (that is, the
6th character in the text). Not all types of look and feel
may support this feature.
void setDisabledIcon(Icon) Attribuer or retourner l’image dans le label quand il est
Icon getDisabledIcon() disabled (activé).
2014-2015 74
Méthodes de l’apparence Descriptions
Attribuer or retourner la zone où le label doit
être placé. L’interface SwingConstants definit 5
void setHorizontalAlignment(int) valeurs possible pour l’alignment horizontal :
void setVerticalAlignment(int) LEFT, CENTER (par défaut pour les labels
int getHorizontalAlignment() d’image seulement), RIGHT, LEADING (par
int getVerticalAlignment() défaut pour les labels text seulement),
TRAILING. Pour l’ alignment vertical : TOP,
CENTER (par défaut) et BOTTOM.
Attribuer or retourner la position où le label
void texte doit être placé, relativement au label image.
setHorizontalTextPosition(int) L’interface SwingConstants definit 5 valeurs
void setVerticalTextPosition(int) possible pour la position horizontal : LEADING,
int getHorizontalTextPosition() LEFT, CENTER, RIGHT, et TRAILING (par
int getVerticalTextPosition() défaut). Pour la position verticale: TOP,
CENTER (par défaut), et BOTTOM.
void setIconTextGap(int) Attribuer ou retourner le nombre de pixels entre
int getIconTextGap() le texte et l’image du label.
setToolTipText(String) Ajouter une infobulle au label. 75
Exemple
import java.awt.Color; import java.awt.Font;
import java.awt.GridLayout; import javax.swing.*;
public class label extends JFrame{
private JPanel pan = new JPanel();
private JLabel lab = new JLabel();
public label(){
this.setTitle("Label"); this.setSize(300, 200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
pan.setBackground(Color.white);
pan.setLayout(new GridLayout(1,1));
Font police = new Font("Tahoma", Font.BOLD, 14); //la police d'écriture
lab.setFont(police); //On l'applique au JLabel
lab.setForeground(Color.blue); //Changement de la couleur du texte
lab.setHorizontalAlignment(JLabel.LEADING); //modifie l'alignement du texte
lab.setText("La classe JLabel ");
System.out.print("Le texte du label est: "+lab.getText());
lab.setDisplayedMnemonic('L'); // on accède au label avec: alt+L
pan.add(lab); this.setContentPane(pan);
this.setVisible(true);
} 2014-2015 76
}
Section 6: Les images (ImageIcon)

2014-2015 77
La classe ImageIcom
 Pour récupérer un fichier image et ensuite pouvoir l'afficher, nous avons
utiliser la classe ImageIcon.
 La classe ImageIcon encapsule une référence à un objet de type Image. C'est
cette référence qui nous est utile pour faire du traitement et notamment pour
l'afficher dans la zone correspondante.
 Voila quelques méthodes de la classe javax.swing.ImageIcon

2014-2015 78
Méthodes Descriptions
ImageIcon() Construit une icône respectivement : vierge, à partir
ImageIcon(byte[] octets) d'un tableau d'octets, à partir d'une image déjà existante,
ImageIcon(Image image) à partir d'un fichier ou à partir d'une localisation
ImageIcon(String nomFichierImage) quelconque.
ImageIcon(URL localisationImage)
int getIconHeight() Renvoie la hauteur de l'image.
int getIconWidth() Renvoie la largeur de l'image.

Image getImage() Récupère l'image proprement dite.

void paintIcon(Component élément, Propose des tracés supplémentaires à l'endroit spécifié.


Graphics surface, int x, int y)
void setImage(Image image) Propose une nouvelle image à l'icône.

2014-2015 79
Remarques
 Cette classe javax.swing.ImageIcon est intéressante.
 Par contre, elle est bloquante au moment du chargement du
fichier image.

 Il y’a la possibilité d'utiliser la classe ImageIO qui possède une


méthode statique read(). On peut utiliser aussi la classe
BufferedImage qui est concrète et qui hérite de la classe abstraite
Image.

2014-2015 80
Exemple
 Quelques exemples de labels:
import java.awt.*; import javax.swing.*;
public class imageicon extends JFrame {
public imageicon() {
this.getContentPane().setLayout(new FlowLayout());
JLabel label1 = new JLabel("Label1");
ImageIcon icon = new ImageIcon("icone.png");
JLabel label2 = new JLabel(icon);
JLabel label3 = new JLabel("Label3", icon, JLabel.CENTER);
// Ajout des labels au cadre
add(label1); add(label2); add(label3);
}
public static void main(String[] args) {
JFrame frame = new imageicon();
frame.pack(); frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
2014-2015 81
}
Résultat

2014-2015 82
Section 7: Les composants texte

2014-2015 83
Présentation [4]
 JTextComponent est un éditeur puissant qui permet d’entrer et de lire le
texte.
 C’est le composant le plus complexe de Swing et il fait partie du paquetage
java.swing.text.

84
Méthodes importantes de JTextComponent
Méthodes Descriptions
int getCaretPosition() Gestion de la position du curseur de texte
void setCaretPosition(int pos) permettant de localiser l'endroit où se fait la saisie.
void moveCaretPosition(int pos)
Color getCaretColor() Spécifie ou récupère la couleur du curseur de
void setCaretColor(Color couleur) texte.
boolean isEditable() Autorise ou empêche la saisie du texte.
void setEditable(boolean valider) setEditable(false): composant est en lecture seule.
String getText(), Permet de récupérer ou ajouter du texte, ou une
void setText(String text), portion de texte.
String getText(int début, int nbCar)
String getSelectedText() Récupère du texte à partir d'une sélection.
int getSelectionStart()
int getSelectionEnd()
2014-2015 85
Méthodes Descriptions
void select(int début, int fin) Sélectionne un texte.
void selectAll()
void setSelectionStart(int début)
void setSelectionEnd(int fin)
Color getSelectedTextColor() Récupère ou change la couleur du texte
void setSelectedTextColor(Color couleur) sélectionné.
Color getSelectionColor() Récupère ou change la couleur de la
void setSelectionColor(Color couleur) sélection (le fond).
void replaceSelection(String texte) Propose un remplacement de texte sur la
partie sélectionnée.
void copy(), void cut(), void paste() Copier, couper et coller à partir du presse-
papier.
void read(Reader flux, Object description) Permet de lire ou de sauvegarder le texte à
void write(Writer flux) partir d'un flux (fichier, réseau, etc.).

2014-2015 86
Classes dérivées de JTextComponent [5]
 C’est une classe abstraite, on ne peut pas construire des objets de type
JTextComponent.

JTextField: collecte une entrée de texte sur JEditorPane: Edite les textes complexes
une seule ligne. formaté ( exp: RTF et HTML).
JPasswordField: spécialisée pour la saisie de JTextPane: hérite de JEditorPane. Permet
mot de passe (remplacé par *). d’afficher plusieurs polices et plusieurs styles
JFormattedTextField: collecte une valeur dans un même document. Elle gère un
numérique ou une date. curseur, la mise en évidence, l'incorporation
JTextArea: collecte une entrée de texte sur d'image, ainsi que d'autres fonctionnalités
plusieurs lignes. élaborées. 87
Champ de texte (JTextField)

2014-2015 88
JTextField: Champ de texte
 Permet à l'utilisateur d'entrer et d'éditer une ligne unique de texte simple.
 On peut utiliser les méthodes propres à la classe JTextField:
 setFont() permet de spécifier la fonte dans lequel le texte sera affiché.
 setColumns() spécifie le nombre de caractères dans le champ. Ce
nombre est approximatif à moins d'employer une fonte à chasse
constante.
Exemple:
 Ce champ de texte a une largeur égale à 20 colonnes.
JTextField saisie = new JTextField("Introduisez votre texte", 20);
 Ce champ est vide.
JTextField saisie = new JTextField(20);

2014-2015 89
Exemple
import java.awt.GridLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class composantstext extends JFrame{
JTextField saisie1 = new JTextField("texte 1", 20);
JTextField saisie2 = new JTextField("texte 2", 20);
private JPanel pan = new JPanel();
public composantstext() {
setTitle("TextField"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(2,1));
pan.add(saisie1);
pan.add(saisie2);
this.add(pan);
this.setVisible(true);
}
public static void main(String[] args) { new composantstext(); }
} 2014-2015 90
Zone de texte (JTextArea)

2014-2015 91
JTextArea: Zone de texte
 JTextArea affiche et édite plusieurs lignes de texte simple non formaté.
 Un utilisateur peut taper n'importe quel nombre de lignes de texte en
utilisant la touche Entrée pour les séparer. Chaque ligne se termine par un
caractère de retour de ligne '\n'.

Exemples:
 Ce constructeur de JTextArea spécifie 8 lignes et 40 colonnes pour la
zone.
JTextArea zone = new JTextArea(8, 40);
 On ajoute une barre de défilement (JScrollPane) à la zone de texte dans
un panneau avec :
JScrollPane ascenceur = new JScrollPane(zone);
2014-2015 92
Méthodes Descriptions
setColumns() et setRows() Modifier le nombre de colonnes et de lignes.
setLineWrap() Active le retour automatique à la ligne.
saisie.setLineWrap(true);
getLineCount() Recenser le nombre de lignes que comporte le texte.
getTabSize() et setTabSize() Récupérer ou spécifier une nouvelle valeur de
tabulation (8 par défaut).
append(texte) Rajouter du texte à la fin de celui qui est déjà présent.
insert(texte, position) Placer du texte à l'endroit spécifié.
replaceRange(texte, début, Remplace le texte par rapport aux bornes proposées.
fin)

2014-2015 93
Exemple
import java.awt.FlowLayout;
import javax.swing.*;
public class composantstext extends JFrame{
JTextArea zone = new JTextArea(8, 40);
JScrollPane ascenceur = new JScrollPane(zone);
private JPanel pan = new JPanel();
public composantstext() {
setTitle("TextArea"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new FlowLayout());
pan.add(ascenceur);
this.add(pan);
this.setVisible(true);
}
} 2014-2015 94
Champ de mot de passe
(JPasswordField)

2014-2015 95
JPasswordField: Champ de mot de passe
 JPasswordField est un type spécial de champ de texte (hérite de JTextField).
 Conçu pour saisir des mots de passe et d'autres donnée sensibles.
 Un caractère d'écho est utilisé à la place, généralement un astérisque (*).

Exemples:
private JPasswordField passe = new JPasswordField();
 Choisir le caractère d'écho à faire apparaître au lieu des caractères entrés par
l'utilisateur avec la méthode setEchoChar():
passe.setEchoChar('#');

 getPassword() renvoie un tableau de caractères et non un objet String.


char[] tab=passe.getPassword();
String chaine=String.valueOf(passe.getPassword()); // cast vers String

2014-2015 96
Exemple
 Traiter les champs de mots de passe:
import java.awt.GridLayout; import javax.swing.*;
public class composantstext extends JFrame{
JTextField saisie1 = new JTextField("texte", 20);
private JPasswordField passe1 = new JPasswordField(20);
private JPasswordField passe2 = new JPasswordField(20);
private JPanel pan = new JPanel();
public composantstext() {
setTitle("JPasswordField"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(3,1));
pan.add(saisie1);
pan.add(passe1);
passe2.setEchoChar('#');
pan.add(passe2);
this.add(pan);
this.setVisible(true);
}
2014-2015 97
}
Champ de saisie mis en forme
(JFormattedTextField)

2014-2015 98
JFormattedTextField: Champ de saisie mis en forme

 JFormattedTextField agit un peu comme JTextField.


 Il accepte dans son constructeur un objet spécifiant le format et gère un
type d'objet complexe (comme Date ou Integer) via ses méthodes
setValue() et getValue().

 Il traite:
 Les valeurs de type date;
 Les valeurs numériques;
 Masque de format: MaskFormatter.

2014-2015 99
Les classes SimpleDateFormat et DateFormat
 SimpleDateFormat prévoit un format de date personnalisé.
private SimpleDateFormat formatDate = new SimpleDateFormat("dd/MM/yyyy");
 Utilisation de ce format:
private JFormattedTextField anniversaire = new JFormattedTextField(formatDate);
anniversaire.setValue(new Date()); /* appel au constructeur de la classe Date pour
initialiser anniversaire. */
Date date = (Date)anniversaire.getValue();

Méthodes Descriptions
getDateInstance() adaptée au formatage des dates selon les
paramètres locaux spécifiés ou par défaut.
getTimeInstance() formate et analyse les heures.
getDateTimeInstance() formate à la fois les dates et les heures.

100
 Traiter un format de date
import java.awt.GridLayout; import java.text.SimpleDateFormat;
import java.util.Date; import javax.swing.*;
public class composantstext extends JFrame{
private SimpleDateFormat formatDate = new SimpleDateFormat("dd/MM/yyyy");
private JFormattedTextField dateNaiss = new
JFormattedTextField(formatDate);
private JPanel pan = new JPanel();
public composantstext() {
setTitle("SimpleDateFormat"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(1,1));
// initialisation de anniversaire avec le constructeur de la classe Date
dateNaiss.setValue(new Date()); // date système
Date date = (Date)dateNaiss.getValue();
pan.add(dateNaiss);
this.add(pan);
this.setVisible(true);
}
}

2014-2015 101
Remarques:
 Il existe divers formats de date:
 Court : 22/11/07
JFormattedTextField date = new JFormattedTextField(DateFormat.getDateInstance(DateFormat.SHORT));
 Moyen (par défaut) : 22 nov. 2007
JFormattedTextField date = new JFormattedTextField(DateFormat.getDateInstance()); //ou DateFormat.MEDIUM.
 Long : 22 novembre 2007
JFormattedTextField date = new JFormattedTextField(DateFormat.getDateInstance(DateFormat.LONG));
 Complet : jeudi 22 novembre 2007
JFormattedTextField date = new JFormattedTextField(DateFormat.getDateInstance(DateFormat.FULL));

2014-2015 102
Exemple
 Traiter plusieurs formats de date
import java.awt.GridLayout;
import javax.swing.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class date extends JFrame{
private SimpleDateFormat formatDate1 = new SimpleDateFormat("'le'
dd/MM/yyyy 'à' hh:mm:ss");
private JFormattedTextField dateNaiss1 = new
JFormattedTextField(formatDate1);
private JFormattedTextField date1 = new
JFormattedTextField(DateFormat.getDateInstance(DateFormat.SHORT));
private JFormattedTextField date2 = new
JFormattedTextField(DateFormat.getDateInstance());
//l’instruction précédente est équivalente à DateFormat.MEDIUM.
private JFormattedTextField date3 = new
JFormattedTextField(DateFormat.getDateInstance(DateFormat.LONG));
private JFormattedTextField date4 = new
JFormattedTextField(DateFormat.getDateInstance(DateFormat.FULL));
103
private JPanel pan = new JPanel();
public date() {
setTitle("SimpleDateFormat"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(5,1));
dateNaiss1.setValue(new Date());
date1.setValue(new Date());
date2.setValue(new Date());
date3.setValue(new Date());
date4.setValue(new Date());
Date date = (Date)dateNaiss1.getValue();
System.out.print("Date et heure : "+date);
System.out.print("Date et heure : "+(Date)date1.getValue());
System.out.print("Date et heure : "+(Date)date2.getValue());
System.out.print("Date et heure : "+(Date)date3.getValue());
System.out.print("Date et heure : "+(Date)date4.getValue());
pan.add(dateNaiss1); pan.add(date1); pan.add(date2);
pan.add(date3); pan.add(date4);
}
}
2014-2015 104
Date et heure : Tue Dec 09 10:31:07 GMT 2014
Date et heure : Tue Dec 09 10:31:07 GMT 2014
Date et heure : Tue Dec 09 10:31:07 GMT 2014
Date et heure : Tue Dec 09 10:31:07 GMT 2014
Date et heure : Tue Dec 09 10:31:07 GMT 2014

2014-2015 105
Les classes NumberFormat et DecimalFormat

//Création du champ en format entier:


private JFormattedTextField âge = new JFormattedTextField(NumberFormat.getIntegerInstance());
// créer un champ et lui donner une valeur par défaut
JFormattedTextField champEntier = new JFormattedTextField(new Integer(37));
JFormattedTextField champEntier = new JFormattedTextField(37);
âge.setValue(new Integer(48)); //Proposer une nouvelle valeur par défaut.
/* la classe Integer qui sert de classe enveloppe pour l'entier 48. L'autoboxing
fonctionne correctement depuis java 5, on peut donc écrire */
âge.setValue(48);
// Récupération des valeurs:
Number nombre = (Number)this.âge.getValue(); // getValue() renvoie un Object
int âge = nombre.intValue(); /* JFormattedTextField renvoie un objet de type
Long si l'utilisateur a modifié la valeur et l'objet Integer initial si ce n'est pas le cas. */

2014-2015 106
Exemple
 Traiter plusieurs entiers:
import java.awt.GridLayout;
import java.text.NumberFormat;
import javax.swing.*;
public class Age extends JFrame{
//Création du champ en format entier:
private JFormattedTextField âge1 = new
JFormattedTextField(NumberFormat.getIntegerInstance());
private JFormattedTextField âge2 = new
JFormattedTextField(NumberFormat.getIntegerInstance());
// créer un champ et lui donner une valeur par défaut
private JFormattedTextField champEntier1 = new
JFormattedTextField(new Integer(37));
private JFormattedTextField champEntier2 = new
JFormattedTextField(37);
private JPanel pan = new JPanel();
2014-2015 107
public Age() {
setTitle("Age");
setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(2,1));
âge1.setValue(new Integer(48)); //valeur par défaut.
âge2.setValue(48);
// Récupération des valeurs:
Number nombre = (Number)this.âge1.getValue();
System.out.println("Le premier âge est: "+nombre.intValue());
System.out.println("Le deuxième âge est:
"+((Number)this.âge1.getValue()).intValue());
System.out.println("La valeur de champEntier1 est: "+
((Number)champEntier1.getValue()).intValue());
System.out.println("La valeur de champEntier2 est: "+
((Number)champEntier2.getValue()).intValue());
pan.add(âge1); pan.add(âge2);
pan.add(champEntier1); pan.add(champEntier2);
this.add(pan);
this.setVisible(true);
}
} 108
Résultat

Le premier âge est: 48


Le deuxième âge est: 48
La valeur de champEntier1 est: 37
La valeur de champEntier2 est: 37

2014-2015 109
Remarques
 On peut prévoir un format numérique personnalisé au moyen de la classe.
DecimalFormat.

private JFormattedTextField résultat;


résultat = new JFormattedTextField(new DecimalFormat("#,##0.00 DH"));

2014-2015 110
Exemple
 Personnaliser le format d’un prix en DH.
import java.awt.GridLayout;
import java.text.DecimalFormat;
import javax.swing.*;
public class Exemple extends JFrame{
private JFormattedTextField résultat = new JFormattedTextField(new
DecimalFormat("#,##.00 DH"));
private JPanel pan = new JPanel();
public Exemple() {
setTitle("DecimalFormat"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(1,1));
résultat.setValue(48.20);
Number nombre= (Number)résultat.getValue();
System.out.println("La valeur est: "+nombre.floatValue());
pan.add(résultat); this.add(pan);
this.setVisible(true);
}
} 111
MaskFormatter: Masque de format
 MaskFormatter permet de mettre en place des masques de saisie.
 Pour les motifs à taille fixe et contenant à la fois des caractères constants et variables.
private JFormattedTextField téléphone;
téléphone = new JFormattedTextField(new MaskFormatter("0#.##.##.##.##"));
téléphone.setValue("06.71.63.55.08");
String téléphone = (String)this.téléphone.getValue();
Symboles de MaskFormatter
# Un chiffre
? Une lettre
U Une lettre, transformée en majuscule
L Une lettre, transformée en minuscule
A Une lettre ou un chiffre
H Un chiffre hexadécimal [0-9A-Fa-f]
* Tout caractère
' Caractère d'échappement pour inclure un symbole dans le motif 112
Exemple
 Traiter un masque pour saisir un numéro de téléphone.

import java.awt.GridLayout;
import java.text.ParseException;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.text.MaskFormatter;
public class masque extends JFrame{
private JFormattedTextField téléphone;
private JPanel pan = new JPanel();
public masque() {
setTitle("SimpleDateFormat"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new GridLayout(1,1));
MaskFormatter mask = null;

2014-2015 113
try{
mask=new MaskFormatter("0#.##.##.##.##");
téléphone= new JFormattedTextField(mask);
téléphone.setValue("06.71.63.50.20");
} catch (ParseException e) {
System.err.println("Impossible d'ajouter le numéro de tel");
}
String tel = (String)this.téléphone.getValue();
System.out.println("Le num de téléphone est: "+tel);
pan.add(téléphone);
this.add(pan);
this.setVisible(true);
}
}

2014-2015 114
Résultat

Le num de téléphone est: 06.71.63.50.20

Le num de téléphone est: 06.71.63

2014-2015 115
La classe JEditorPane

2014-2015 116
La classe JEditorPane
 Swing propose des possibilités de texte sophistiquées par
l'intermédiaire de deux autres classes filles de JTextComponent:
JEditorPane et JTextPane (qui hérite de JEditorPane).

 JEditorPane permet l'affichage et l'édition de texte complexe formaté


comme des documents HTML et RTF, en conjonction avec les classes
des paquetages javax.swing.text.html et javax.swing.text.rtf.

 Dans ce cours, on se limitera à la classe JTextPane.

2014-2015 117
La classe JTextPane
 Les composants texte de base JTextField et JTextArea, sont limités à
une seule police dans un seul style.

 JTextPane permet d’afficher plusieurs polices et plusieurs styles dans


un même composant. Elle gère également un curseur, la mise en
forme, l'incorporation d'image, ainsi que d'autres fonctionnalités
élaborées.

2014-2015 118
Exemple

2014-2015 119
Code
import java.awt.Color; import java.awt.FlowLayout;
import javax.swing.JFrame; import javax.swing.JTextPane;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;

public class Exemple extends JFrame {


JTextPane textPane = new JTextPane();

public Exemple() {
setTitle("Exemple avec JTextPane");
setBounds(100, 100, 350, 250);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
getContentPane().setLayout(new FlowLayout());

2014-2015 120
textPane.setBounds(80, 40, 120, 150);
textPane.setText( "1ère ligne" );
StyledDocument doc = textPane.getStyledDocument();

// Definir le style1
SimpleAttributeSet style1 = new SimpleAttributeSet();
StyleConstants.setForeground(style1, Color.RED);
StyleConstants.setBackground(style1, Color.YELLOW);
StyleConstants.setBold(style1, true);

SimpleAttributeSet style2 = new SimpleAttributeSet();


StyleConstants.setForeground(style2, Color.BLUE);

2014-2015 121
// Ajouter du texte
try {
doc.insertString(doc.getLength(), "\n2ème ligne", null );
doc.insertString(doc.getLength(), "\n3ème ligne", style1);
doc.insertString(doc.getLength(), "\n4ème ligne", style2);
doc.insertString(doc.getLength(), "\n", null );
doc.insertString(doc.getLength(), "\n5ème ligne", style2);
}
catch(Exception e) { System.out.println(e); }

getContentPane().add(textPane);
}

public static void main(String[] args) {


Exemple frame = new Exemple();
frame.setVisible(true);
}
}
2014-2015 122
Quelques méthodes de la classe JTextPane
Méthodes Descriptions
Style getStyle(String nom) Récupère, propose un nouveau style à ceux
Style addStyle(String nom, Style parent) existants suivant une hiérarchie, ou enlève un des
void removeStyle(String nom) styles de la hiérarchie.
void insertComponent(Component Ajoute un composant quelconque ou une image.
composant), void insertIcon(Icon image)
void setCharacterAttributes(AttributeSet Spécifie les attributs, comme la taille de la fonte et
attribut, boolean remplacer) le style, qui s'appliquent aux caractères individuels.
Met à jour les attributs du texte sélectionné courant
ou, s'il n'y a pas de sélection, spécifie les attributs à
appliquer au texte inséré plus tard. L'argument
booléen remplacer indique si ces attributs doivent
remplacer les anciens ou doivent s'y ajouter.
AttributeSet getParagraphAttributes() Restitue ou spécifie les attributs, comme les marges
void setParagraphAttributes(AttributeSet et la justification, sur un paragraphe entier.
attribut, boolean remplacer)
2014-2015 123
La programmation événementielle
[7]

2014-2015 124
Plan de la partie 2
 Introduction
 Section 1: Evénement de type Action et événement liés à
la souris
 Section 2: Notion d'adaptateur - Classe anonyme
 Section 3: Recensement des différents types d'événement
 Section 4: Les champs de formulaires

2014-2015 125
Introduction
 La programmation événementielle constitue la caractéristique
essentielle d'une interface graphique.

 La plupart des événements sont créés par des composants introduits


dans la fenêtre (les menus, les boutons, les boîtes de dialogues, etc).
 Le modèle d’événement AWT, contrôle complètement la manière dont
les événements sont transmis de la source (exp: un bouton ou une
barre de défilement) à l'écouteur (celui qui va capturer et gérer
l'événement).
 N'importe quel objet peut être un écouteur d'événement. Dans la
pratique, on choisit un objet écouteur capable de fournir une réponse
appropriée à l'événement.

2014-2015 126
 Les sources d'événement possèdent des méthodes addXXXListener() qui
leur permettent d'enregistrer les écouteurs d'événement sélectionnés
XXXListener. Lorsqu'un événement arrive à la source, celle-ci envoie une
notification à tous les objets écouteurs recensés pour cet événement.

 L'information relative à l'événement est encapsulée dans un objet


événement. Tous les objets événement dérivent, directement ou
indirectement, de la classe java.util.EventObject. Il existe des sous-classes
pour chaque type d'événement, comme ActionEvent et WindowEvent.

2014-2015 127
 Les événements sont gérés par l'AWT comme suit:
 Un objet écouteur est une instance d'une classe qui implémente une
interface spéciale appelée interface écouteur (listener interface).
 Une source d'événement est un objet qui est capable de recenser des
objets écouteurs et leur envoyer des objets événements.
 Lorsqu'un événement se produit, la source d'événement envoie l'objet
événement à tous les écouteurs recensés.
 Les objets écouteurs utilisent alors l'information contenue dans l'objet
événement pour déterminer leur réponse.

2014-2015 128
 On recense l'objet écouteur auprès de l'objet source avec l’instruction sur ce modèle:
ObjetSourceEvénement.addEvénementListener(objetEcouteurEvénement)
Exemple:
ActionListener écouteur = ...;
JButton bouton = new JButton("Ok");
bouton.addActionListener(écouteur);
 Il faut que la classe à laquelle appartient l'objet écouteur implémente l'interface
appropriée (en l'occurence, ActionListener) càd redéfinir les méthodes prévues avec
la signature correcte.
 Pour implémenter l'interface ActionListener, la classe de l'écouteur doit posséder la
méthode actionPerformed() qui reçoit l'objet ActionEvent en paramètre :
class Ecouteur implements ActionListener {
...
public void actionPerformed(ActionEvent événement) {
// traitement particulier à la réaction d'un clic sur le bouton
...
}
2014-2015 129
}
Explication
ActionListener écouteur = ...;
JButton bouton = new JButton("Ok");
bouton.addActionListener(écouteur);

class Ecouteur implements ActionListener {


public void actionPerformed(ActionEvent événement) {
// traitement particulier à la réaction d'un clic sur le bouton
}
}

 Lorsque l'utilisateur clique sur le bouton, l'objet bouton crée un objet


événement de type ActionEvent et appelle la méthode
écouteur.actionPerformed(événement) en lui passant cet objet.
 Il est possible d'ajouter plusieurs objets en tant qu'écouteurs d'une source
d'événement, par exemple un bouton. Dans ce cas, le bouton appelle les
méthodes actionPerformed() de tous les écouteurs, chaque fois que
l'utilisateur clique sur ce bouton.
2014-2015 130
Section 1: Evénement de type Action et
événement liés à la souris

2014-2015 131
Evénement de type Action et
événement liés à la souris

 L’interface ActionListener
 L’interface MouseListener
 Choix de l'objet écouteur

2014-2015 132
L’interface ActionListener
import java.awt.*; import javax.swing.*;
import java.awt.event.*; // package pour les événements
public class Exemple extends JFrame implements ActionListener {
private JTextField saisie = new JTextField(20);
private JButton BVider = new JButton("Vider");
private JPanel pan = new JPanel();
public Exemple() {
setTitle("Vider un TextField"); setBounds(100,100,350,80);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new FlowLayout());
BVider.addActionListener(this); // la fenêtre est écouteur
pan.add(saisie); pan.add(BVider); add(pan);
setVisible(true);
}
public void actionPerformed(ActionEvent e) {
saisie.setText("");
}
133
}
Remarques
 L'interface ActionListener utilisée dans l’exemple n'est pas limitée aux clics
sur des boutons, elle peut être utilisée dans bien d'autres situations, par
exemple :
 Lors de la sélection d'un élément de menu.
 Lors de la sélection d'un élément dans une liste avec un double-clique.
 Lorsque la touche "Entrée" est activée dans un champ de texte. On
peut ajouter la ligne: saisie.addActionListener(this);
 Lorsqu'un composant Timer déclenche une impulsion après
l'écoulement d'un temps donné.
 En résumé, ActionListener s'utilise de la même manière dans toutes les
situations qu’on vient d'évoquer; sa unique méthode actionPerformed()
reçoit en paramètre un objet de type ActionEvent. Cet objet fournit des
informations sur l'événement qui a été déclenché.
2014-2015 134
 Java est très souple concernant le choix de l'écouteur. On peut créer
ses propres classes ou utiliser celles qui sont déjà présentes.
L’important, c'est que la ou les méthodes relatives aux événements
puissent réaliser le traitement souhaité.

 Dans notre exemple, il est indispensable de pouvoir atteindre l'objet


saisie, puisque le traitement à réaliser est en relation avec cet élément.
Vu qu’on n’a qu'un seul bouton qui provoque l'événement, il est
judicieux que ce soit la fenêtre elle-même qui soit écouteur de ce type
d'événement puisqu'elle dispose des éléments qu’on vient d'évoquer et
qui vont donc servir au traitement.

 Également, il est possible de créer une nouvelle classe spécifique à la


gestion de cet événement mais, pour qu'elle puisse accéder à l’objet
saisie, il faut que ce soit impérativement une classe interne. Ce sujet
sera traiter ultérieurement.
2014-2015 135
L’interface MouseListener
 Cet exemple traite l'événement d'un clic sur un label ou une surface.
 La surface (objet de JPanel) se trouve sur la fenêtre.
 L'événement affiche les coordonnées de la souris sur un label ou sur la
surface (coordonnées objet de la classe Coordonnées).

import java.awt.*; import javax.swing.*; import java.awt.event.*;


public class Exemple extends JFrame{
private JLabel labelClic = new JLabel("Cliquer
ici",JLabel.CENTER);
private JLabel labelCoor= new JLabel("Cliquer sur le label pour
retrouver les coordonnées",JLabel.CENTER);
private JPanel pan= new JPanel(); 136
public Exemple() {
setTitle("Exemple de MouseListener");
setSize(250,150);
pan.setLayout(new GridLayout(2, 1));
pan.add(labelClic);
pan.add(labelCoor);
add(pan);
//La classe Coordonnées est l'écouteur d'événement
//Le label est la source d'événement
labelClic.addMouseListener(new Coordonnées());
/* pour chercher les coorconnées de tous les points du panel
exécuter le code suivant:
pan.addMouseListener(new Coordonnées());*/
setVisible(true);
}

2014-2015 137
class Coordonnées implements MouseListener{
// Traitement à faire en cas de clic sur le label
public void mouseClicked(MouseEvent e) {
labelCoor.setText("Coordonnées de la souris:
("+e.getX()+", "+e.getY() +")");
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
}

public static void main(String[] args){


new Exemple();
}

2014-2015 138
Explication
 Pour traiter un clic de la souris dans la surface de travail de la fenêtre, il
suffit d'associer à notre surface un objet d'un type tel que MouseListener
(EcouteurSouris). Pour ce faire, on utilise la méthode addMouseListener()
(le nom de la méthode est évocateur puisque qu'il est associé au type
d'écouteur - add+MouseListener):
sourceEvénement.addMouseListener(objetEcouteur);
 objetEcouteur est un objet d'une classe du type MouseListener dont on
vient de fournir le schéma et sourceEvénement correspond à la surface de
travail.

labelClic.addMouseListener(new Coordonnées());
pan.addMouseListener(new Coordonnées());

source ecouteur
2014-2015 139
 La classe Coordonnés implémente l'interface MouseListener.
 JLabel permet d’utiliser la méthode setText() et de proposer l'affichage des
coordonnées de la souris.
class Coordonnées implements MouseListener{
public void mouseClicked(MouseEvent e) {
labelCoor.setText("Coordonnées de la souris:
("+e.getX()+", "+e.getY() +")");
}
}

 L'argument transmis à la méthode mouseClicked() est un objet de type


MouseEvent. Cette classe correspond à la catégorie d'événements gérés
par l'interface MouseListener. Un objet de cette classe est
automatiquement créé par Java lors du clic, et transmis à l'écouteur voulu.
Il contient un certain nombre d'informations, en particulier les
coordonnées du curseur de la souris au moment du clic, lesquelles sont
accessibles, respectivement, par les méthodes getX() et getY().
140
Remarques
 En java, tout événement possède ce que l'on nomme une source. Il s'agit
de l'objet qui lui avait donné naissance, comme un bouton, un article de
menu, une fenêtre, un panneau, etc. Dans notre exemple, cette source est
un label ou la surface de travail.

 Pour traiter un événement, on doit associer à la source un objet de son


choix dont la classe implémente une interface particulière correspondant à
une catégorie d'événements. On dit que cet objet est un écouteur de cette
catégorie d'événements. Chaque méthode proposée par l'interface
correspond à un événement particulier de la catégorie choisie.

2014-2015 141
 Ainsi, il existe une catégorie d'événements souris qu’on peut traiter à l'aide
d'un écouteur de souris, càd un objet d'une classe implémentant l'interface
MouseListener. Cette dernière comporte cinq méthodes correspondant
chacune à un événement particulier:
 mousePressed(): appuie sur un bouton de la souris.
 mouseReleased(): relâchement de l'action sur un bouton de la souris.
 mouseClicked(): clic sur un bouton de la souris qui correspond en
réalité à un appuie suivie d'un relâchement.
 mouseEntered(): le curseur de la souris passe au dessus de l'élément
source.
 mouseExited(): le curseur sort de la zone prise par l'élément source.

2014-2015 142
 La classe susceptible d'instancier un objet écouteur de ces différents
événements correspond à ce schéma :
class EcouteurSouris implements MouseListener{
public void mouseClicked(MouseEvent e) {...}
public void mousePressed(MouseEvent e) {...}
public void mouseReleased(MouseEvent e) {...}
public void mouseEntered(MouseEvent e) {...}
public void mouseExited(MouseEvent e) {...}
// autres méthodes et attributs de la classe.
}

 On doit proposer une classe écouteur qui redéfinie la méthode


mouseClicked() afin de réaliser le traitement souhaité.
 La classe implémente l'interface MouseListener, elle doit également
redéfinir toutes les autres méthodes.
 On peut se permettre de ne rien faire de particulier pour toutes ces
méthodes supplémentaires non utiles pour l’application. La définition de
ces méthodes sera donc "vide".
2014-2015 143
Choix de l'objet écouteur
 Java est très souple puisque l'objet écouteur peut être n'importe quel objet
dont la classe implémente l'interface voulue.

 Dans une situation aussi simple qu'ici, on peut ne pas créer de classe séparée
telle que Coordonnées en faisant de la fenêtre elle-même son propre
écouteur d'événement souris.

 Ceci est possible car la seule chose qu’on demande à un objet écouteur est
que sa classe implémente l'interface voulue (ici MouseListener).

2014-2015 144
public class Exemple extends JFrame implements MouseListener{
// les déclarations restent les mêmes
public Exemple() {
// ce code reste le même
// Le cadre devient maintenant l'écouteur d'événement
labelClic.addMouseListener(this);
}
public void mouseClicked(MouseEvent e) {
labelCoor.setText("Coordonnées de la souris:
("+e.getX()+", "+e.getY() +")");
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
}
2014-2015 145
Section 2: Notion d'adaptateur -
Classe anonyme

2014-2015 146
Notion d'adaptateur
 Dans les exemples précédents, on n'avait besoin que de la méthode:
mouseClicked(). Or, on a dû fournir des définitions vides pour toutes les
autres méthodes afin d'implémenter correctement l'interface MouseListener.
 Une classe qui implémente une interface doit obligatoirement définir toutes
les méthodes de l'interface.
 Pour faire simple, chacune des interfaces AWT possédant plusieurs méthodes
est accompagnée d'une classe adaptateur qui implémente toutes les méthodes
de l'interface en leur attribuant des instructions vides.
class MouseAdapter implements MouseListener{
public void mouseClicked(MouseEvent e) {...}
public void mousePressed(MouseEvent e) {...}
public void mouseReleased(MouseEvent e) {...}
public void mouseEntered(MouseEvent e) {...}
public void mouseExited(MouseEvent e) {...}
}
MouseAdapter possède 5 méthodes qui ne font rien. 147
 La classe adapatateur satisfait automatiquement aux exigences techniques
imposées par Java pour l'implémentation de l'interface écouteur qui lui est
associée.
 On peut étendre la classe adaptateur afin de spécifier les réactions
souhaités pour certains événements, mais sans avoir besoin de répondre
explicitement à tous les événements de l'interface.
 Une interface comme ActionListener, qui ne possède qu'une seule
méthode, n'a pas besoin de classe adaptateur.
On va étendre la classe MouseAdapter, héritant de 5 méthodes qui ne font rien, et
on va surcharger la méthode mouseClicked() :
public class Fenêtre extends JFrame {

source.addMouseListener(new EcouteurSouris());

class EcouteurSouris extends MouseAdapter{
public void mouseClicked(MouseEvent e) {…}

}
} 2014-2015 148
Classe anonyme
 On procède 2 classes indépendantes Fenêtre et EcouteurSouris.
 Dans certains programmes, on préfère que la fenêtre concernée soit son
propre écouteur.
 Dans ce cas, un petit problème se pose : la classe fenêtre correspondante
ne peut pas dériver à la fois de JFrame et de MouseAdapter.
 Donc, on va utiliser une classe anonyme en remplaçant le canevas 1 par 2.

149
class Fenêtre extends JFrame {

source.addMouseListener(new EcouteurSouris());
1 …
class EcouteurSouris extends MouseAdapter{
public void mouseClicked(MouseEvent e) {…}

}
}

class Fenêtre extends JFrame {



2 source.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent e) {…}
});

}

150
Exemple
 Utilisation d’un objet de type classe anonyme dérivée de MouseAdapter et
dans laquelle on redéfit la méthode mouseClicked().
import java.awt.*; import java.awt.event.*; import javax.swing.*;

public class Exemple extends JFrame {


// Les déclarations restent les mêmes
public Exemple() {
setTitle("Exemple de MouseListener"); setSize(350,150);
pan.setLayout(new GridLayout(2, 1));
pan.add(labelClic); pan.add(labelCoor); add(pan);
labelClic.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent e) {
labelCoor.setText("Coordonnées de la souris: ("+e.getX()+
", "+e.getY() +")");
}
});
setVisible(true);
}
public static void main(String[] args){ new Exemple(); }
}
2014-2015 151
Récapitulatif
 Un événement, déclenché par un objet nommé source, pouvait être
traité par un autre objet nommé écouteur préalablement associé à la
source.
 Tout ce qui a été exposé ici, sur deux exemples simples, se généralisera
aux autres événements, quels qu'ils soient et quelle que soit leur source.
 On associe toujours un objet écouteur à un événement d'une catégorie
donnée ##Listener par une méthode add##Listener(). Chaque fois
qu'une catégorie donnée disposera de plusieurs méthodes, nous
pourrons :
 soit redéfinir toutes ces méthodes, certaines ayant éventuellement
un corps vide,
 soit faire appel à une classe dérivée d'une classe adaptateur -
##Adapter - et ne fournir que les méthodes qui nous intéressent.

2014-2015 152
 N'importe quel objet peut être un écouteur; il peut être l'objet source lui-
même. En plus, un même événement peut avoir plusieurs écouteurs:
 Les sources d'événement sont des composants de l'interface utilisateur,
des fenêtres et des menus.
 Le SE notifie à une source d'événement, les activités qui peuvent
l'intéresser: mouvements de la souris ou les frappes du clavier.
 La source d'événement décrit la nature de l'événement dans un objet
événement: ##Event. Elle stocke aussi une liste d'écouteur ##Listener
des objets qui souhaitent être prévenus quand l'événement se produit.
 La source d'événement appelle la méthode appropriée de l'interface
écouteur afin de fournir des informations sur l'événement aux divers
écouteurs recensés. Ainsi, la source passe l'événement objet adéquat à la
méthode de la classe écouteur.
 L'écouteur analyse l'objet événement pour obtenir des informations
détaillées. exemple, on utilise la méthode getSource() pour connaître la
source, Par ou les méthodes getX() et getY() de la classe MouseEvent
pour connaître la position courante de la souris. 153
Section 3: Recensement des différents types
d'événement (Evénements sémantiques et de
bas niveau- Ecouteurs d'événement - Classes
adaptateur - Eléments employés pour la gestion
des événements)

2014-2015 154
Listes des différents types d'événement
 Tous les événements de Java utilisés par les composants graphiques de
Swing sont des classe filles de java.util.EventObject.
 Un objet événement encapsule des informations sur l'événement que la
source d'événement communique aux écouteurs, à l'aide des méthodes
getSource() et getActionCommand() dans les exemples précédents.
 Il y’a:

2014-2015 155
Evénements sémantiques et de bas niveau
 AWT fait une distinction utile entre événements de bas niveau et
événements sémantiques :
 Un événement sémantique exprime ce que fait l'utilisateur, par
exemple "Cliquer sur un bouton"; en conséquence, un événement
ActionEvent est sémantique.
 Les événements de bas niveau sont ceux qui rendent l'action possible.
 Exemples: Dans le cas d'un clic sur un bouton de l'interface utilisateur:
une pression sur le bouton de la souris, des déplacements du pointeur de
la souris, puis un relâchement du bouton de la souris (mais seulement si le
pointeur se trouve encore dans la zone du bouton affiché à l'écran). Ce
peut être également une pression sur une touche du clavier, au cas où
l'utilisateur sélectionne le bouton avec la touche de tabulation puis active
la barre d'espacement. De la même manière, un ajustement de la position
d'une barre de défilement est un événement sémantique, mais le
déplacement de la souris est un événement de bas niveau.
156
Les classes les plus utilisés dans le paquetage java.awt.event
Les événements sémantiques:
Evénements Descriptions
ActionEvent pour un clic de bouton, une sélection d'un élément de menu
ou de liste, ou pression sur "Entrée" dans un champ de texte.
AdjustementEvent l'utilisateur déplace le curseur d'une barre de défilement.
ItemEvent l'utilisateur fait une sélection dans un groupe de cases à cocher
ou dans une liste.

Les événements de bas niveau:


KeyEvent une touche du clavier est enfoncée ou relâchée.
MouseEvent le bouton de la souris est enfoncée ou relâchée ; le pointeur
de la souris se déplace ou glisse.
MouseWheelEvent la molette de la souris tourne.
FocusEvent un composant obtient le focus.
WindowsEvent l'état de la fenêtre change. 157
Remarques
 Tous les événements de bas niveau héritent de ComponentEvent.
Cette classe dispose de la méthode getComponent(), qui indique le
composant ayant généré l'événement; on peut employer
getComponent() à la place de getSource(). En effet, la méthode
getComponent() renvoie la même valeur que getSource(), mais l'a déjà
transtypée en Component.
 Exemple: si un événement clavier a été déclenché à la suite d'une
frappe dans un champ de texte, getComponent() renvoie une référence
à ce champ de texte.

getComponent() <=> (Component)getSource()

2014-2015 158
Ecouteurs d'événement
 ActionListener - AjustementListener - FocusListener - ItemListener -
KeyListener - MouseListener - MouseMotionListener -
MouseWheelListener - WindowsListener - WindowsFocusListener -
WindowsStateListener.

Remarques:
 Il y’a deux interfaces séparées pour la souris, pour des raisons
d'efficacité : MouseListener et MouseMoveListener.
 La deuxième est plutôt spécialisée au mouvement de la souris. Il se
produit de nombreux événements lorsque l'utilisateur déplace la souris.
 Un écouteur qui s'intéresse uniquement aux clics de la souris ne doit
pas être inutilement prévenu de tous les déplacements de la souris.

2014-2015 159
Classes adaptateur
 Plusieurs interfaces écouteur AWT, et qui possèdent plusieurs
méthodes, sont accompagnées d'une classe adaptateur qui implémente
toutes les méthodes de l'interface afin qu'elles n'accomplissent aucune
action (les autres interfaces n'ont qu'une seule méthode et il est donc
inutile d'employer des classes adaptateur dans ce cas).
 Les classes adaptateur les plus souvent utilisées sont: FocusAdapter -
KeyAdapter - MouseAdapter - MouseMotionAdapter -
WindowAdapter.
 Il faut manifestement connaître un grand nombre de classes et
d'interfaces - ce qui peut paraître insurmontable à première vue.
 Heureusement, le principe est simple. Une classe qui désire recevoir
des événements doit implémenter une interface écouteur. Elle se
recense auprès de la source d'événement, puis elle reçoit les
événements souhaités et les traite grâce aux méthodes de l'interface
écouteur. 2014-2015 160
Eléments employés pour la gestion des événements
 Les objets événements les plus utilisés et leurs méthodes associées:

Evénements et descriptions Méthodes associées


EventObject getSource() : Renvoie une référence sur l'objet qui a
Généré par tous les composants. déclenché l'événement.
Objet parent de tous les objets
événement.
InputEvent isAltDown(), isControlDown(), isMetaDown(),
Généré par tous les composants. isShiftDown() : Ces méthodes renvoient true si la
Objet parent de KeyEvent et de touche de modification correspondante est pressée
MouseEvent. lorsque l'événement est généré.
FocusEvent isTempory() : indique si le changement de focus est
Généré par Component. temporaire ou permanent.
Un composant a obtenu ou getOppositeComponent() : Renvoie le composant
perdu le focus. qui a perdu le focus dans le gestionnaire
focusGained ou celui qu’il a obtenu dans focusLost.
Evénements et descriptions Méthodes associées
ComponentEvent getComponent() : indique le composant ayant généré
Généré par tous les l'événement.
composants.
Tous les événements de bas
niveau héritent de cette classe.
ActionEvent getActionCommand() : renvoie la chaîne de
Généré par AbstractButton, commande associée à cet événement d'action. Si cet
JComboxBox, JTextField, événement est déclenché par un bouton, la chaîne de
Timer. commande contient le libellé du bouton, à moins
Pour un clic de bouton, une qu'il n'ait été modifié par la méthode
sélection d'un élément de menu setActionCommand().
ou de liste, une pression de la getModifiers() : renvoie une valeur qui indique les
touche Entrée dans un champ modificateurs clavier - alt, ctrl, shift - qui sont
de texte. effectifs quand l'événement de d'action est
déclenché.

2014-2015 162
Evénements et descriptions Méthodes associées
AdjustementEvent getAjustable() : retourne l'objet qui a provoqué
Généré par JScrollBar. l'événement.
L'utilisateur a déplacé le getAdjustementType() : indique comment se déroule
curseur d'une barre de le défilement. Voici les différentes valeurs retournées :
défilement. UNIT_INCREMENT, UNIT_DECREMENT,
BLOCK_INCREMENT, BLOCK_DECREMENT,
TRACK.
getValue() : retourne la valeur courante de l'ascenseur.
ItemEvent getItem() : renvoie un objet représentant l'item qui a
Généré par AbstractButton, été sélectionné ou désélectionné.
JComboxBox. getItemSelectable() : est un remplacement commode à
L'utilisateur fait une sélection getSource(), et renvoie l'objet ItemSelectable qui a
dans un groupe de case à déclenché l'événement.
cocher ou dans une liste. getStateChange() : renvoie le nouvel état de sélection
de l'item : une des constante SELECTED ou
DESELECTED.

2014-2015 163
Evénements et descriptions Méthodes associées
KeyEvent getKeyChar() : Renvoie le caractère tapé par
Généré par Component. l'utilisateur.
Une touche du clavier a été getKeyCode() : renvoie le code de touche virtuel de
pressée ou relâchée. cet élément du clavier - VK_0, VK_A, VK_LEFT, ...
getKeyModifiersText() : renvoie une chaîne décrivant
les touches de modification comme shift ou ctrl+shift.
getKeyText() : Renvoie une chaîne décrivant le code
de touche. Par exemple,
getKeyText(KeyEvent.VK_END) renvoie "End" (ou
"Fin" si votre version Java est localisée).
isActionKey() : renvoie true si la touche de cet
événement est une touche "d'action" - Origine, Fin,
Page précédente, Tabulation, etc.

2014-2015 164
Evénements et Méthodes associées
descriptions
MouseEvent getX(), getY(), getPoint() : Renvoie la coordonnée x, la
Généré par Component. coordonnée y et le point sur lequel s'est produit
Le bouton de la souris a l'événement, dans le système de coordonnées de la
été enfoncé ou relâché; le source.
pointeur de la souris a été getClickCount() : Renvoie le nombre de clics de souris
déplacé, ou glissé dans une consécutifs associés à l'événement.
opération de glisser- translatePoint() : exécute un déplacement relatif des
déplacer. coordonnées de la souris.
isPopupTrigger() : renvoie true si le bouton concerné
(généralement le droit) est celui traditionnellement
réservé au menu surgissant.
MouseWheelEvent getWheelRotation() : indique le nombre d'impulsions
Généré par Component. correspondant à la rotation de la molette.
La molette de la souris getScrollAmount() : donne l'unité de mesure de chaque
tourne. impulsion.

2014-2015 165
Evénements et Méthodes associées
descriptions
WindowEvent getWindow() : détermine l'objet Window qui est la source
Généré par Window. de l'événement.
La fenêtre a été activée, getOppositeWindow() : retourne la fenêtre qui possédait
désactivée, réduite en (anciennement) le focus.
icône, ré ouverte ou getNewState(), getOldState() : Ces méthodes renvoient
fermée. l'ancien état et le nouvel état d'une fenêtre dans un
événement de modification de l'état de fenêtre. L'entier
renvoyé correspond à l'une des valeurs suivantes :
Frame.NORMAL, Frame.ICONIFIED,
Frame.MAXIMIZED_HORIZ,
Frame.MAXIMIZED_VERT,
Frame.MAXIMIZED_BOTH.

2014-2015 166
 Interfaces et classes adaptateur les plus utilisés et leurs méthodes
associées:
Evénements et descriptions Méthodes associées
ActionListener actionPerformed(ActionEvent) : traitement à
Ecouteur qui prend en compte un réaliser après une validation venant de
choix ou une validation. l'utilisateur.
AdjustementListener adjustmentValueChanged(AdjustementEvent) :
Ecouteur qui prend en compte le traitement à réaliser après une modification du
déplacement du curseur d'une barre curseur de la barre de défilement.
de défilement.
ItemListener itemStateChanged(ItemtEvent) : traitement à
Ecouteur qui prend en compte la réaliser après la sélection.
sélection dans un groupe de cases à
cocher ou dans une liste.
FocusListener - FocusAdapter focusGained(FocusEvent) : traitement à réaliser
Ecouteur qui prend en compte la avec l'obtention du focus.
sélection dans un groupe de cases à focusLost(FocusEvent) : traitement à réaliser
cocher ou dans une liste. après la perte du focus. 167
Evénements et descriptions Méthodes associées
KeyListener - KeyAdepter keyPressed(KeyEvent) : une touche du clavier a été
Ecouteur qui prend en pressée.
compte le clavier. keyReleased(KeyEvent) : une touche du clavier a été
relâchée.
Pour le clavier keyTyped(KeyEvent) : appelée (en plus des deux
précédentes), lorsque le caractère est définitivement
saisie, avec la prise en compte des modificateurs ou
des touches de fonction ou encore des séquences de
touches multiples.

2014-2015 168
Evénements et descriptions Méthodes associées
MouseListener - mousePressed(MouseEvent) : l'utilisateur a appuyer
MouseAdapter sur un bouton de la souris.
Ecouteur qui prend en compte mouseReleased(MouseEvent) : l'utilisateur a relâché
les événements venant de la le bouton de la souris.
souris (mais pas les événements mouseEntered(MouseEvent) : généré chaque fois
liés aux mouvements de la que la souris passe de l'extérieur à l'intérieur d'un
souris). composant.
mouseExited(MouseEvent) : généré chaque fois
que la souris passe de l'intérieur à l'extérieur d'un
composant.
mouseCliqued(MouseEvent): clic complet de la
souris avec un appui suivi du relâchement sans
déplacement entre temps.
MouseMotionListener - mouseDragged(MouseEvent) : l'utilisateur a
MouseMotionAdapter déplacé la souris en maintenant un bouton
Ecouteur qui prend en compte enfoncé.
les événements liés aux mouseMoved(MouseEvent) : l'utilisateur a déplacé
mouvements de la souris. la souris sans tenir de bouton enfoncé. 169
Evénements et descriptions Méthodes associées
MouseWheelListener mouseWheelMoved(MouseWheelEvent) : traitements
Ecouteur qui prend en en relation avec la rotation de la molette de la souris.
compte les événements liés à
la molette de la souris.

2014-2015 170
Evénements et Méthodes associées
descriptions
WindowListener - windowClosing(WindowEvent) : l'utilisateur veut fermer la
WindowAdapter fenêtre par le menu système ainsi que par le bouton de
Ecouteur qui prend fermeture. Cette fenêtre ne se fermera qu'avec un appel à sa
en compte le méthode hide() (rendre invisible) ou dispose().
changement d'état windowClosed(WindowEvent) : envoyé après qu'une fenêtre a
de la fenêtre. été fermée par un appel à hide() ou dispose().
windowOpened(WindowEvent) : cette méthode est appelée
lorsque la fenêtre a été ouverte.
windowIconified(WindowEvent) : la fenêtre est réduite (en icône
ou en bouton).
windowDeiconified(WindowEvent): la fenêtre est restaurée (elle
retrouve sa taille initiale alors qu'elle était réduite).
windowActivated(WindowEvent) : Envoyé quand la fenêtre est
activée. La fenêtre active est généralement repérée par une barre
de titre en surbrillance. Une seule fenêtre ne peut être active à un
moment donné.
windowDeactivated(WindowEvent) : Envoyé quand la fenêtre
cesse d'être la fenêtre active, quand l'utilisateur active une autre.
Evénements et descriptions Méthodes associées
WindowFocusListener - windowGainedFocus(WindowEvent):
WindowFocusAdapter traitement à réaliser avec l'obtention du
Ecouteur qui prend en compte le focus ou un de ses éléments.
changement de focus sur la windowLostFocus(WindowEvent):
fenêtre. traitement à faire après la perte du focus.
WindowStateListener windowStateChanged(WindowEvent):
Ecouteur qui prend en compte le traitement à réaliser au changement d'état.
changement d'état de la fenêtre
(maximisée, réduite en icône ou
restaurée à sa taille normale).

Remarque:
C'est loin d'être exhaustif, mais cela donne une idée de ce qu’on peut
réaliser. Il s'agit ici des éléments les plus souvent utilisés.

2014-2015 172
Section 4: Les champs de formulaires
(Les listes, les cases à cocher, les boutons
radio, les boîtes de dialogue et les menus,
les onglets, JList)
[8]

2014-2015 173
Les listes (JComboBox)

2014-2015 174
Exemple avec JComboBox
import java.awt.*; import javax.swing.*;

public class Exemple extends JFrame {


private JPanel pan1 = new JPanel();
private JComboBox combo = new JComboBox();

private JLabel label = new JLabel("ComboBox");

public Exemple(){
this.setTitle("ComboBox"); this.setSize(300, 300);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
pan1.setBackground(Color.white);
combo.setForeground(Color.blue);
pan1.setLayout(new BorderLayout());
combo.setPreferredSize(new Dimension(100, 20)); 175
combo.addItem("Option 1");
combo.addItem("Option 2");
combo.addItem("Option 3");
combo.addItem("Option 4");
/* ou bien utiliser le constructeur qui prend un tableau
d'objets en entrée et ajoute tous les éléments d'un coup.
String[] tab={"Option 1","Option 2","Option 3","Option 4"};
combo = new JComboBox(tab);
*/
JPanel pan1(JPanel pan2(label+combo))
JPanel pan2 = new JPanel();
pan2.add(label); pan2.add(combo);
pan1.add(pan2, BorderLayout.NORTH);
this.setContentPane(pan1); this.setVisible(true);
}
public static void main(String[] args) { new Exemple (); }
}

2014-2015 176
JComboBox et l'interface ItemListener
 L’interface ItemListener a la méthode itemStateChanged(ItemEvent) à redéfinir,
appelée lors du changement d'état qu'un élément.
// Ajouter les bibilothèques suivantes
import java.awt.event.ItemEvent; import java.awt.event.ItemListener;
public class Exemple extends JFrame {
// Les déclarations restent les mêmes
public Exemple (){ Résultat: Affiche les items
précédent et actuel
// Le code reste le même événement déclenché sur : Option 1
// Ajout de l’écouteur événement déclenché sur : Option 2
combo.addItemListener(new Choix()); événement déclenché sur : Option 2
} événement déclenché sur : Option 3
class Choix implements ItemListener{ /*Classe interne implémente
ItemListener */
public void itemStateChanged(ItemEvent e) {
System.out.println("événement déclenché sur :"+e.getItem());
}
} 177
}
JComboBox et l'interface ActionListener
 L'interface ActionListener permet de récupérer l'option sélectionnée.
public class Exemple extends JFrame {
Résultat: Affiche l’item séléctionné
// Les déclarations restent les mêmes ActionListener : action sur Option 2
public Exemple (){ ActionListener : action sur Option 4
// Le code reste le même ActionListener : action sur Option 1
// Ajout de l’écouteur ActionListener : action sur Option 2
combo.addActionListener(new Choix());

}
class Choix implements ActionListener{
public void actionPerformed(ActionEvent e) {
System.out.println("ActionListener : action sur " +
combo.getSelectedItem()); }
}  getSelectedItem() retourne la
valeur de l'option sélectionnée.
}  setSelectedIndex(int index):
assigne un choix par défaut.
Les cases à cocher (JCheckBox)

2014-2015 179
Exemple avec JCheckBox
import java.awt.*; import javax.swing.*;
public class Exemple extends JFrame {
private JPanel pan1 = new JPanel();
private JCheckBox check1 = new JCheckBox("Case 1");
private JCheckBox check2 = new JCheckBox("Case 2");
public Exemple(){
this.setTitle(" CheckBox ");
this.setSize(300, 200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
pan1.setBackground(Color.white);
pan1.setLayout(new BorderLayout());

2014-2015 180
check1.setSelected(true); // case 1 est cochée par défaut
check1.addActionListener(new EcouteurEtat());
check2.addActionListener(new EcouteurEtat());
JPanel pan2 = new JPanel();
pan2.add(check1); pan2.add(check2);
pan1.add(pan2, BorderLayout.NORTH);
this.setContentPane(pan1); this.setVisible(true);
}
class EcouteurEtat implements ActionListener{
public void actionPerformed(ActionEvent e) {

System.out.println("source:"+((JCheckBox)e.getSource()).getText()
+"-état:"+((JCheckBox)e.getSource()).isSelected());
}
} Boolean isSelected():
contrôle si l’objet est coché.
public static void main(String[] args) { new Exemple(); }
}
2014-2015 181
Résultat

Résultat:
source : Case 1 - état : true
source : Case 2 - état : true

2014-2015 182
Le bouton radio (JRadioButton)

2014-2015 183
Exemple avec JRadioButton
 JRadioButton propose au moins 2 choix et ne permet de sélectionner qu'un seul
bouton à la fois.

import java.awt.*; import javax.swing.*;


public class Exemple extends JFrame {
private JPanel pan1 = new JPanel();
private JRadioButton radio1 = new JRadioButton("Homme");
private JRadioButton radio2 = new JRadioButton("Femme");
ButtonGroup groupe= new ButtonGroup();
public Exemple(){
this.setTitle("RadioButton"); this.setSize(300, 300);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
pan1.setBackground(Color.white);
pan1.setLayout(new BorderLayout());

2014-2015 184
radio1.setSelected(true);
radio1.setMnemonic('H'); radio2.setMnemonic('F');
groupe.add(radio1); groupe.add(radio2);
radio1.addActionListener(new StateListener());
radio2.addActionListener(new StateListener());
JPanel pan2 = new JPanel();
pan2.add(radio1); pan2.add(radio2);
pan1.add(pan2, BorderLayout.NORTH);
this.setContentPane(pan1); this.setVisible(true);
}
class StateListener implements ActionListener{
public void actionPerformed(ActionEvent e) {

System.out.println("source:"+((JRadioButton)e.getSource()).getText()
+"-état:"+((JRadioButton)e.getSource()).isSelected());
}
}
public static void main(String[] args) { new Exemple(); }
} 185
Résultat

Résultat:
source:Homme-état:true
source:Femme-état:true
source:Homme-état:true

2014-2015 186
Les boîtes de dialogue
et les menus

2014-2015 187
Les boîtes de dialogue
[9, 10]

2014-2015 188
Présentation
 Les dialogues sont des conteneurs de premier niveau (comme JFrame): ils
ne sont pas contenus dans d’autres cadres.
 Un dialogue peut être :
 modal: lorsqu’il est actif, toute interaction avec les autres fenêtres sont
bloquées. Les dialogues JOptionPane sont modaux.
 non modal: ne bloque pas les interactions avec les autres fenêtres: pour
créer un dialogue non modal, il faut utiliser la classe JDialog.
 La classe JOptionPane permet de créer des dialogues élémentaires
modaux en spécifiant un message, un titre, une icône et un type de message
ou un type d’option. Les types de boîtes qu’on peut afficher sont:
 JOptionPane.ERROR_MESSAGE
 JOptionPane.INFORMATION_MESSAGE
 JOptionPane.PLAIN_MESSAGE
 JOptionPane.QUESTION_MESSAGE
 JOptionPane.WARNING_MESSAGE 189
 Si on ne spécifie pas d’icône, des icônes sont fournies par le système en
fonction du type de message.
 Les boites de dialogues servent à:
 afficher une information (message d'erreur, d'avertissement, etc.) ;
 demander une validation, un refus ou une annulation ;
 demander à l'utilisateur de saisir une information dont le système a
besoin ;
 etc.
 On va voir les types de boites de dialogue suivantes:
 Les boîtes d'information;
 Les boîtes de confirmation;
 Les boîtes de saisie;
 Des boîtes de dialogue personnalisées.

2014-2015 190
Les boîtes d'information
 On utilise la méthode showMessageDialog(Component
parentComponent, String message, String title, int messageType); où :
 Component parentComponent: correspond au composant parent;
ici, il n'y en a aucun, on met donc null.
 String message: permet de renseigner le message à afficher dans la
boîte de dialogue.
 String title: permet de donner un titre à l'objet.
 int messageType: permet de savoir s'il s'agit d'un message
d'information, de prévention ou d'erreur.

 La méthodes showMessageDialog() est surchargée. Il existe une


méthode qui prend deux paramètres en moins (le titre et le type de
message), et une autre qui prend un paramètre en plus (l'icône à
utiliser). 2014-2015 191
Exemple
 On crée 3 boites d’information.
 On va ranger les 3 images dans un dossier « images » à la racine du projet Eclipse.
import javax.swing.ImageIcon; import javax.swing.JOptionPane;
public class Exemple {
public static void main(String[] args) {
JOptionPane jop1, jop2, jop3;
jop1=new JOptionPane(); jop2=new JOptionPane(); jop3=new JOptionPane();
ImageIcon img1 = new ImageIcon("images/information.jpg");
ImageIcon img2 = new ImageIcon("images/warning.jpg");
ImageIcon img3= new ImageIcon("images/erreur.jpg");
jop1.showMessageDialog(null,"Msg informatif","Information",
JOptionPane.INFORMATION_MESSAGE, img1);
jop2.showMessageDialog(null,"Msg préventif","Attention",
JOptionPane.WARNING_MESSAGE, img2);
jop3.showMessageDialog(null, "Msg d'erreur", "Erreur",
JOptionPane.ERROR_MESSAGE, img3);
}
}
2014-2015 192
Résultat

Remarque: On peut ajouter lors d'une division par zéro, la boîte d’information
erreur dans le bloc catch.
2014-2015 193
Les boîtes de confirmation
 Elles permettent de valider, d'invalider ou d'annuler une décision.
 On utilise la méthode showConfirmDialog(), elle retourne un entier
correspondant à l'option choisie dans cette boîte : Yes; No; Cancel.

 On utilise l’une des options de message suivantes :


 JOptionPane.DEFAULT_OPTION;
 JOptionPane.YES_NO_OPTION;
 JOptionPane.YES_NO_CANCEL_OPTION;
 JOptionPane.OK_CANCEL_OPTION;
 La valeur retournée par la méthode est: OK_OPTION/YES_OPTION(0),
NO_OPTION(1) ou CANCEL_OPTION(2).
Exemple
import javax.swing.*; import java.awt.*;
public class Exemple extends JFrame {
public Exemple(String titre) {
super(titre);setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
sortieAvecConf();
}
});
JPanel pan = new JPanel();
pan.setPreferredSize(new Dimension(400, 150));
pan.setBackground(Color.WHITE); getContentPane().add(pan);
setVisible(true);
pack();
}

195
void sortieAvecConf() {
if (JOptionPane.showConfirmDialog(this,
"Voulez-vous vraiment quitter ce programme?",
"Attention!",
JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)
System.exit(0);
}
public static void main(String[] args) {
new Exemple("Confirmation de sortie");
}
}

2014-2015 196
Les boîtes de saisie
 Ces boites de dialogues permettent d’y saisir du texte.
 On utilise la méthode showInputDialog(Component parent, String
message, String title, int messageType), qui retourne une chaîne de
caractères.

2014-2015 197
Exemple 1
import javax.swing.JOptionPane;
public class Exemple{
public static void main(String[] args) {
JOptionPane jop1 = new JOptionPane();
JOptionPane jop2 = new JOptionPane();
String nom = jop1.showInputDialog(null, "Veuillez entrer
votre identité !", "Demande d'identité !",
JOptionPane.QUESTION_MESSAGE);
jop2.showMessageDialog(null, "Votre nom est" + nom,
"Identité", JOptionPane.INFORMATION_MESSAGE);
}
}

2014-2015 198
Exemple 2
import javax.swing.JOptionPane;
public class Exemple {
public static void main(String[] args) {
String[] coul = {"noir", "blanc", "vert", "rouge", "bleu",
"jaune", "orange"};
JOptionPane jop1= new JOptionPane(), jop2= new JOptionPane();
String nom = (String)jop1.showInputDialog(null, "Veuillez
indiquer votre couleur préférée !","Demande de la couleur
préférée !", JOptionPane.QUESTION_MESSAGE,null,coul,coul[2]);
// La méthode retourne un objet de type Object (combo), il faut faire un
cast.
jop2.showMessageDialog(null,"Votre couleur préférée est:
"+nom,"Couleur préférée", JOptionPane.INFORMATION_MESSAGE);
}
}

199
Des boîtes de dialogue personnalisées
 Les boîtes de dialogue héritent de la classe JDialog.

2014-2015 200
Exemple
import java.awt.*; import javax.swing.*;
public class Exemple extends JFrame {
private JButton bouton = new JButton("Appel à la Boite de
Dialogue");
public Exemple (){
this.setTitle("Ma fenêtre"); this.setSize(300, 100);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.getContentPane().setLayout(new FlowLayout());
this.getContentPane().add(bouton);
bouton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
BDialog bd = new BDialog(null, "La Boite de
Dialogue", true); }
});
this.setVisible(true);
} 2014-2015 201
public class BDialog extends JDialog {
public BDialog(JFrame parent, String title, boolean modal){
super(parent, title, modal); //appel au construteur de JDialog
- JFrame parent correspond à l'objet parent;
- String title correspond au titre de notre boîte;
- boolean modal correspond à la modalité; true : boîte modale, false : boîte non modale.

this.setSize(200, 80);
this.setLocationRelativeTo(null);
this.setResizable(false);
this.setVisible(true);
}
}
public static void main(String[] main){ new Exemple ();}
}

2014-2015 202
Les menus

2014-2015 203
Présentation de JMenu et JMenuItem
 La classe JMenu permet de créer le titre principal d'un point de menu
(Fichier, Édition, etc.) ;
 La classe JMenuItem permet d’ajouter les éléments composants nos
menus.

2014-2015 204
Exemple

2014-2015 205
Exemple
import java.awt.*; import javax.swing.*;
public class Exemple extends JFrame {
private JMenuBar menuBar = new JMenuBar();
// ajout des menus
private JMenu Mfichier = new JMenu("Fichier");
private JMenu Msous_fichier = new JMenu("Sous ficher");
private JMenu Medition = new JMenu("Edition");
// ajout des items de menus
private JMenuItem MIouvrir = new JMenuItem("Ouvrir");
private JMenuItem MIfermer = new JMenuItem("Fermer");
private JMenuItem MIcopier = new JMenuItem("Copier");
private JMenuItem MIcoller = new JMenuItem("Coller");
//ajout des items de menu de type cases à cocher
private JCheckBoxMenuItem MIchoix1 = new JCheckBoxMenuItem("Choix 1");
private JCheckBoxMenuItem MIchoix2 = new JCheckBoxMenuItem("Choix 2");

206
//ajout des items de menu de type boutons radio
private JRadioButtonMenuItem MIradio1=new JRadioButtonMenuItem("Radio 1");
private JRadioButtonMenuItem MIradio2=new JRadioButtonMenuItem("Radio 2");
public Exemple (){
this.setTitle("Un Menu"); this.setSize(400, 200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.Mfichier.add(MIouvrir);
this.Msous_fichier.add(MIchoix1); // Ajout des sous-menus
this.Msous_fichier.add(MIchoix2);
this.Msous_fichier.addSeparator(); //Ajout d'un séparateur
ButtonGroup bg = new ButtonGroup(); //groupe des radios
bg.add(MIradio1); bg.add(MIradio2);
MIradio1.setSelected(true); //présélectionne de radio 1
this.Msous_fichier.add(MIradio1);
this.Msous_fichier.add(MIradio2);
this.Mfichier.add(this.Msous_fichier); //Ajout du sous-menu
this.Mfichier.addSeparator(); //Ajout d'un séparateur

207
MIfermer.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0){
System.exit(0); }
});
this.Mfichier.add(MIfermer);
this.Medition.add(MIcopier);
this.Medition.add(MIcoller);
/* L'ordre d'ajout va déterminer l'ordre d'apparition dans
le menu de gauche à droite.
Le premier ajouté sera tout à gauche de la barre de menu et
inversement pour le dernier. */
this.menuBar.add(Mfichier); this.menuBar.add(Medition);
this.setJMenuBar(menuBar);
this.setVisible(true);
}

public static void main(String[] args){new Exemple(); }


}
2014-2015 208
Méthodes [15]
Quelques fonctions utiles Descriptions
mb.add(un menu) Ajout des menus dans une
barre de menu.
mb.add(Box.createHorizontalGlue()); mb.add( un menu); Cadrer un menu à droite.
menu.setText("Mon Menu"); Affecte le texte du menu.
menu.setIcon(new
Affecte l'icône du menu .
ImageIcon(getClass().getResource("/testswing/icone.gif")));
menu.setMnemonic(KeyEvent.VK_M); affecter le raccourci alt+M
menu.add(un item) Ajout des items au menu.
Insère une séparation dans la
menu.addSeparator()
liste des items.
mi.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z affectation de l'accélérateur
, Event.CTRL_MASK, true)); ctrl+z
mi.setEnabled(true); l'item de menu est actif.
Menu contextuel JPopupMenu [11]
 JPopupMenu est un menu qui apparait à la demande de l’utilisateur
suite à un clique sur le bouton droit de la souris.

2014-2015 210
Exemple
import java.awt.*; import java.awt.event.*;
import javax.swing.*; import javax.swing.border.*;
import javax.swing.event.*;
public class Exemple extends JPanel {
public JPopupMenu popup;
public Exemple() {
popup = new JPopupMenu();
ActionListener menuListener = new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("Popupmenu item["+
event.getActionCommand() +"] est pressé."); }
};

2014-2015 211
JMenuItem item;
popup.add(item=new JMenuItem("Gauche", new
ImageIcon("images/gauche.jpg")));
item.setHorizontalTextPosition(JMenuItem.RIGHT);
item.addActionListener(menuListener);
popup.add(item = new JMenuItem("Droit", new
ImageIcon("images/droite.jpg")));
item.setHorizontalTextPosition(JMenuItem.RIGHT);
item.addActionListener(menuListener);
popup.add(item = new JMenuItem("Haut", new
ImageIcon("images/haut.jpg")));
item.setHorizontalTextPosition(JMenuItem.RIGHT);
item.addActionListener(menuListener);
popup.add(item = new JMenuItem("Bas", new
ImageIcon("images/bas.jpg")));
item.setHorizontalTextPosition(JMenuItem.RIGHT);
item.addActionListener(menuListener);
212
popup.addSeparator();
popup.add(item = new JMenuItem("Propriétés"));
item.addActionListener(menuListener);
popup.setLabel("Justification");
popup.setBorder(new BevelBorder(BevelBorder.RAISED));
popup.addPopupMenuListener(new MessagPopup());
addMouseListener(new MousePopupListener());
}

2014-2015 213
/* An inner class to check whether mouse events are the popup
trigger */
class MousePopupListener extends MouseAdapter {
public void mousePressed(MouseEvent e){ checkPopup(e); }
public void mouseClicked(MouseEvent e) { checkPopup(e); }
public void mouseReleased(MouseEvent e) { checkPopup(e);}
private void checkPopup(MouseEvent e) {
if (e.isPopupTrigger()) {//visualiser les messages
popup.show(Exemple.this, e.getX(), e.getY()); }
}
}

2014-2015 214
// An inner class to show when popup events occur
class MessagPopup implements PopupMenuListener {
public void popupMenuWillBecomeVisible(PopupMenuEvent e){
System.out.println("Popup menu sera visible!");
}
public void popupMenuWillBecomeInvisible(PopupMenuEvent e){
System.out.println("Popup menu sera invisible!");
}
public void popupMenuCanceled(PopupMenuEvent e) {
// clic sue Echap
System.out.println("Popup menu est caché!");
}
}

2014-2015 215
public static void main(String s[]) {
JFrame frame = new JFrame("Popup Menu");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setContentPane(new Exemple());
frame.setSize(300, 300);
frame.setVisible(true);
}
}

2014-2015 216
Les onglets (JTabbedPane)
[12, 13]

2014-2015 217
Présentation
 Le JTabbedPane est un conteneur qui contient d'autres conteneurs.
 La navigation entre ces différents conteneurs se fait par des onglets.
Les onglets de navigation peuvent être positionnés à gauche, en haut, à
droite ou en bas.
 Un onglet est un JComponent (en général un JPanel).

2014-2015 218
Hiérarchie de JTabbedPane

2014-2015 219
Méthodes d’ajout et de retrait d'onglets
Méthodes Descriptions
Ajoute un nouveau composant en tant qu'onglet, ayant
Component add(Component c)
pour titre le nom du composant obtenu par getName().
Component add(Component c, Ajoute un nouveau composant en tant qu'onglet, ayant
int index) pour titre le nom du composant, à l'indice index.
Ajoute un nouveau composant en tant qu'onglet, ayant
void add( Component c, Object
pour titre le nom du composant. Si contrainte est une
contrainte )
chaîne de caractère ou une icône, elle sert de titre.
Ajoute un nouveau composant en tant qu'onglet, ayant
void add(Component c, Object pour titre le nom du composant, à l'indice index. Si
contrainte, int index) contrainte est une chaîne de caractère ou une icône,
elle sert de titre.
Component add(String titre, Ajoute un nouveau composant en tant qu'onglet, ayant
Component c) pour titre titre.
void addTab(String titre, Ajoute un nouveau composant en tant qu'onglet, ayant
Component c) pour titre titre.
2014-2015 220
Méthodes Descriptions
void addTab(String titre, Ajoute un nouveau composant en tant qu'onglet, ayant
Icon icone, Component c) pour titre titre, pour icône icone.
void addTab(String titre,
Ajoute un nouveau composant en tant qu'onglet, ayant
Icon icone, Component c,
pour titre titre, pour icône icone, et pour conseil tip.
String tip)
void insertTab(String titre, Insère un nouveau composant en tant qu'onglet, ayant
Icon icone, Component c, pour titre titre, pour icône icone, et pour conseil tip. Le
String tip, int index) nouvel onglet est inséré à l'indice index.
Enlève le composant c. La méthode ne fait rien si c est
void remove(Component c)
null.
Enlève l'onglet d'indice index. La méthode peut lever une
void remove(int index)
exception IndexOutOfBoundsException.
void removeTab(int index) Enlève l'onglet d'indice index.
void removeAll() Enlève tous les onglets.

2014-2015 221
Méthodes de configuration du JTabbedPane
Méthodes Descriptions
Positionne le placement des onglets :
• JTabbedPane.TOP : en haut
void setTabPlacement( int p) • JTabbedPane.BOTTOM : en bas
• JTabbedPane.LEFT : à gauche
• JTabbedPane.RIGHT : à droite
int getTabPlacement() Retourne la valeur du placement des onglets.
Positionne la stratégie adoptée par la JTabbedPane
lorsque les onglets ne tiennent plus sur une seule ligne:
• JTabbedPane.WRAP_TAB_LAYOUT : création d'une
void setTabLayoutPolicy(int s) deuxième ligne d'onglets quand il n'y a plus de place
pour tous les onglets.
• JTabbedPane.SCROLL_TAB_LAYOUT : mise en
place d'une barre de défilement pour les onglets.
int getTabLayoutPolicy() Retourne la stratégie précédente.
2014-2015 222
Méthodes de sélection d'un panneau du
JTabbedPane

Méthodes Descriptions
void setSelectedIndex( int i) Sélectionne le panneau d'indice i.
int getSelectedIndex() Retourne l'indice du panneau sélectionné.
int getTabCount() Retourne le nombre d'onglets.

2014-2015 223
Exemple
import java.awt.*; import javax.swing.*;
class Exemple extends JFrame {
private JTabbedPane tabbedPane;
private JPanel pan1, pan2, pan3;

public Exemple() {
// on utilise des panels sans layouts.
setTitle("TabbedPane");
setSize(300, 200);
setBackground(Color.gray);

JPanel topPan = new JPanel();


topPan.setLayout(new BorderLayout());
getContentPane().add( topPan );
224
// Création des pages
createPage1();
createPage2();
createPage3();

// Création de tabbedPane
tabbedPane = new JTabbedPane();
tabbedPane.addTab( "Onglet 1", pan1 );
tabbedPane.addTab( "Onglet 2", pan2 );
tabbedPane.addTab( "Onglet 3", pan3 );
topPan.add( tabbedPane, BorderLayout.CENTER );
}

2014-2015 225
public void createPage1() {
pan1 = new JPanel();
pan1.setLayout(null);
JLabel lnom = new JLabel( "Nom de l'utilisateur:" );
lnom.setBounds( 10, 15, 150, 20 );
pan1.add(lnom);
JTextField nom = new JTextField();
nom.setBounds(10, 35, 150, 20);
pan1.add(nom);

JLabel lpasse = new JLabel("Mot de passe:");


lpasse.setBounds(10, 60, 150, 20);
pan1.add(lpasse);
JPasswordField passe = new JPasswordField();
passe.setBounds(10, 80, 150, 20);
pan1.add(passe);
}

2014-2015 226
public void createPage2() {
pan2 = new JPanel();
}

public void createPage3() {


pan3 = new JPanel();
}

public static void main(String args[]) {


Exemple cadre= new Exemple();
cadre.setVisible(true);
}
}

2014-2015 227
JList
[14]

2014-2015 228
Présentation
 Jlist est un composant qui permet:
 l'affichage d'une liste d'éléments;
 le parcours de la liste;
 la sélection d'un ou plusieurs éléments.
 Un JList peut être créé à partir d'un tableau d'objets, ou à partir d'un
Vector, mais si on veut une liste qui peut être mise à jour par
programme, il faut utiliser un ListModel.
 ListSelectionModel décrit le modèle de sélection dans la liste
(possibilité de sélectionner plusieurs éléments, etc.). Par défaut, Jlist
utilise un DefaultListSelectionModel.

2014-2015 229
 Les items de la liste peuvent être affichés (setLayoutOrientation) de trois
façons différentes :
 JList.HORIZONTAL_WRAP: Les items sont rangés ligne par ligne sur
un nombre de lignes défini par setVisibleRowCount. Si le nombre de
lignes visibles est -1, le nombre de ligne est calculé pour afficher le
maximum d'items dans le JList.
 JList.VERTICAL_WRAP: Les items sont rangés colonne par colonne
sur un nombre de lignes défini par setVisibleRowCount. Si le nombre
de lignes visibles est -1, le nombre de ligne est calculé pour afficher le
maximum d'items dans le JList.
 JList.VERTICAL: les items sont affichés sur une seule colonne.

230
 La sélection des items se fait suivant trois modes :
 javax.swing.ListSelectionModel.SINGLE_SELECTION: sélection d'un
seul item.
 javax.swing.ListSelectionModel.SINGLE_INTERVAL_SELECTION:
sélection possible de plusieurs items, mais contigus.
 javax.swing.ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
sélection possible de plusieurs items sur plusieurs intervalles.

2014-2015 231
Hiérarchie de JList

2014-2015 232
Exemple 1
 On va créer la liste suivante. Elle va écrire dans une étiquette le jour de
la semaine sélectionné dans la liste.

 Les éléments de la liste sont lus à partir d’un tableau.

2014-2015 233
import javax.swing.*; import java.awt.*;
import javax.swing.event.*;

public class Exemple extends JFrame implements


ListSelectionListener {
JList liste = new JList();
JLabel label = new JLabel(" ");
public Exemple() {
String choix[] = {"Lundi", "Mardi", "Mercredi", "Jeudi",
"Vendredi", "Samedi", "Dimanche"};
this.setTitle("JList"); this.setBounds(600,200,350,200);
liste = new JList(choix); // Liste à partir d’un tableau
liste.addListSelectionListener(this);
add(label, BorderLayout.WEST);
add(liste, BorderLayout.EAST);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
2014-2015 234
public void valueChanged(ListSelectionEvent evt) {
label.setText("Le jour sélectionné est:
"+(String)liste.getSelectedValue());
}
public static void main(String[] arg) {
new Exemple();
}
}

2014-2015 235
Exemple 2
 Dans ce 2ème exemple, on va créer la liste suivante.
 Elle va permettre d’ajouter, renommer, supprimer et vider la liste.
 Pour pouvoir modifier la liste affichée par le JList, il faut utiliser un
JList construit avec un modèle.
 La classe DefaultListModel offre une implantation permettant
d'ajouter et d'enlever des items de la liste.

2014-2015 236
import java.awt.*; import java.awt.event.*;
import javax.swing.*;
public class Exemple{
public static void main(String[] args) {
final DefaultListModel model = new DefaultListModel();
final JList list = new JList(model);
JFrame f = new JFrame(); f.setTitle("JList models");
model.addElement("A"); model.addElement("B");
model.addElement("C"); model.addElement("D");
model.addElement("E");
JPanel pan = new JPanel();
pan.setLayout(new BoxLayout(pan, BoxLayout.X_AXIS));
JPanel leftPan = new JPanel();
JPanel rightPan = new JPanel();
leftPan.setLayout(new BorderLayout());
rightPan.setLayout(new BoxLayout(rightPan,
BoxLayout.Y_AXIS));
2014-2015 237
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list.setBorder(BorderFactory.createEmptyBorder(2,2,2,2));
list.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
int index = list.locationToIndex(e.getPoint());
Object item = model.getElementAt(index);
String text=JOptionPane.showInputDialog("Renommer item", item);
String nouvitem = "";
if (text != null) nouvitem = text.trim();
else return;
if (!newitem.isEmpty()) {
model.remove(index);
model.add(index, newitem);
ListSelectionModel selmodel = list.getSelectionModel();
selmodel.setLeadSelectionIndex(index); }
}
}
2014-2015 238
});
2014-2015 239
leftPan.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
leftPan.add(new JScrollPane(list));
JButton removeall = new JButton("Tout supprimer");
JButton add = new JButton("Ajouter");
JButton rename = new JButton("Renommer");
JButton delete = new JButton("Supprimer");

2014-2015 240
add.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String text = JOptionPane.showInputDialog("Ajouter un
nouveau item");
String item = null;
if (text != null)
item = text.trim();
else return;
if (!item.isEmpty())
model.addElement(item);
}
});

2014-2015 241
delete.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
ListSelectionModel selmodel = list.getSelectionModel();
int index = selmodel.getMinSelectionIndex();
if (index >= 0)
model.remove(index);
}
});

2014-2015 242
rename.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ListSelectionModel selmodel = list.getSelectionModel();
int index = selmodel.getMinSelectionIndex();
if (index == -1) return;
Object item = model.getElementAt(index);
String text = JOptionPane.showInputDialog("Renommer un
item", item);
String nouvitem = null;
if (text != null) { nouvitem = text.trim(); }
else return;
if (!newitem.isEmpty()) {
model.remove(index);
model.add(index, newitem);
}
}
});

2014-2015 243
removeall.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
model.clear(); }
});
rightPan.add(add); rightPan.add(rename);
rightPan.add(delete); rightPan.add(removeall);

rightPan.setBorder(BorderFactory.createEmptyBorder(0,0,0,20));
pan.add(leftPan);
pan.add(rightPan);
f.add(pan);

f.setSize(350, 250); f.setLocationRelativeTo(null);


f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}

2014-2015 244
Méthodes
Méthodes Descriptions
int getLayoutOrientation() Retourne le mode d'affichage des données.
void setLayoutOrientation( int o) Affecte le mode d'affichage des données.
int getSelectionMode() Retourne le mode de sélection des données.
void setSelectionMode( int sm) Affecte le mode de sélection des données.
Affecte le nombre de lignes visibles quand le
mode d'affichage est HORIZONTAL_WRAP
void setVisibleRowCount( int l) ou VERTICAL_WRAP. (Si l vaut -1, le nombre
de lignes est calculé par le JList pour que le
maximum de données soient visibles).
void ensureIndexVisible(int index) Assure que l'item au rang index est visible.
void clearSelection() Plus aucun item sélectionné.
boolean isSelectionEmpty() Retourne true s'il n'y a aucun item sélectionné.

2014-2015 245
Méthodes Descriptions
int getLastVisibleIndex() Retourne l'indice du dernier item visible.
int getSelectedIndex() Retourne l'indice de l'item sélectionné.
Retourne les indices des items
int[] getSelectedIncices()
sélectionnés.
void setSelectedIndex(int i) Affecte l'indice de l'item sélectionné.
void setSelectedIndices(int [] i) Affecte les indices des items sélectionnés.
Object getSelectedValue() Retourne la valeur de l'item sélectionné.
L'item sélectionné devient v. Si b vaut
void setSelectedValue(Object v, boolean b)
true, il est rendu visible dans le JList.
Retourne un tableau des items
Object[] getSelectedValues()
sélectionnés.
Retourne le modèle de données affiché
ListModel getModel()
par le JList.
Le nouveau modèle de données affiché
void setModel(ListModel lm)
par le JList est lm.
Références
[1] : http://bet-nafet.ma/expert/Java/Tutoriels/IHM/Fenetre.html
[2]: http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-
en-java/notre-premiere-fenetre
[3] : http://jacques.bapst.home.hefr.ch/ihm1/cours/ihm1_05.pdf]
[https://docs.oracle.com/javase/tutorial/uiswing/components/label.html
[4] : http://www2.htw-
dresden.de/~beck/JAVA11/SWING/api/com.sun.java.swing.JTextPane.ht
ml
[5] : https://docs.oracle.com/javase/tutorial/uiswing/components/text.html
[6] : http://fr.wikipedia.org/wiki/Mod%C3%A8le-vue-
contr%C3%B4leur#En_Java

2014-2015 247
[7]: http://bet-nafet.ma/expert/Java/Tutoriels/Evenements/Evenements.htm
[8]: http://fr.openclassrooms.com/informatique/cours/apprenez-a-
programmer-en-java/les-champs-de-formulaire
[9]: http://imss-www.upmf-grenoble.fr/prevert/Prog/Java/dialogue.htm
[10]: http://fr.openoms.com/informatique/cours/apprenez-a-programmer-en-
classrojava/les-menus-et-boites-de-dialogue
[11]: http://www.java2s.com/Code/Java/Swing-
JFC/AsimpleexampleofJPopupMenu.htm
[12]: http://imss-www.upmf-
grenoble.fr/prevert/Prog/Java/swing/JTabbedPane.html
[13]:
http://www.cs.cf.ac.uk/Dave/HCI/HCI_Handout_CALLER/node61.html
#SECTION00077500000000000000
[14]: http://imss-www.upmf-grenoble.fr/prevert/Prog/Java/swing/JList.html
[15]: http://imss-www.upmf-grenoble.fr/prevert/Prog/Java/swing/menu.html

248