Les fondements du langage Java

Chapitre 6
Création de GUIs (AWT / Swing)

Pr. Mohammed OUANAN

LST Informatique 2015-2016 M. OUANAN

Généralités sur AWT

♦ AWT est une interface utilisateur offrant un ensemble de classes et de

fonctions pour le développement des interfaces graphiques

♦ AWT fut introduite dès java 1.0. Depuis Java 1.2, SWING a très largement
remplacé AWT

♦ AWT regroupe toutes les fonctionnalités communes à tous les systèmes

graphiques pour la manipulation des objets GUI

♦ AWT fait appel à l’afficheur natif du système local pour dessiner les
composantes graphiques
 AWT n’est pas totalement indépendante de l’OS:
- Avantage: rendement graphique plus rapide
- Inconvénients: apparence différente d’un système à l’autre

-2-
Services fournis par AWT

♦ 5 services sont proposés au programmeur :

1. Un ensemble de composants GUI usuels (control/widgets)

2. La notion d’objets Containers qui fournissent un support et un

contexte aux composants GUI utilisés

3. Des gestionnaires d’affichage permettant de positionner les

composants GUI ajoutés à un container

4. Un support basique de fonctions de dessin tels : dessin d’un trait,

rectangle, polygones…

5. Un gestionnaire d’événement qui permet au programmeur de

déclarer les événements que l’application doit gérer.

-3-
Conteneurs et composants

Une interface graphique en Java est un assemblage conteneurs (Container)

et de composants (Component).

Un composant est une partie "visible" de l'interface utilisateur Java.

C’est une sous-classes de la classe abstraite java.awt.Component.
Exemple : les boutons, les zones de textes ou de dessin, etc.

Un conteneur est un espace dans lequel on peut positionner plusieurs

composants.
Sous-classe de la classe java.awt.Container
La classe Container est elle-même une sous-classe de la classe
Component
Par exemple les fenêtres, les applets, etc.

-4-
Conteneurs et composants

Object

B utton
(from l a ng ) Hiérarchie d’héritage
des principaux éléments des
Canvas Component
interfaces graphiques en Java

Ch eckbox

Container
Choice

Label
Panel W indow

Scrollbar List

Dial og Frame
A pplet
TextComponent
(from ap p le t)

FileDialog
TextArea TextField

-5-
Les principaux composants de l’AWT

♦ Un composant est tout simplement un élément que l'on peut inclure dans une
interface graphique. Les classes décrivant ces composants héritent d'une
superclasse appelée Component, de même que toutes les classes (appartenant
au package java.awt) que nous verrons dans ce chapitre. Voici quelques exemples:

. Button : permet de créer un bouton

. Checkbox (associé à CheckboxGroup) : case à cocher,

. Choice : pour créer une liste déroulante,

. Label : permet d'afficher un label (zone de texte),

. List : utilisé afin de constituer une liste dont plusieurs éléments peuvent être sélectionnés
simultanément,

. Scrollbar : pour afficher des ascenseurs,

. TextArea : permet de construire une zone de saisie sur plusieurs lignes,

. TextField : comme une TextArea mais ne permet la saisie que d'une seule ligne.

-6-
Conteneurs et composants

■ Les deux conteneurs les plus courants sont le Frame et le Panel.

■ Un Frame représente une fenêtre de haut niveau avec un titre, une

bordure et des angles de redimensionnement.
 La plupart des applications utilisent au moins un Frame comme point
de départ de leur interface graphique.

■ Un Panel n'a pas une apparence propre et ne peut pas être utilisé comme
fenêtre autonome.
 Les Panels sont créés et ajoutés aux autres conteneurs de la même
façon que les composants tels que les boutons
 Les Panels peuvent ensuite redéfinir une présentation qui leur soit
propre pour contenir eux-mêmes d'autres composants.

-7-
Conteneurs et composants

• On ajoute un composant dans un conteneur, avec la méthode

add() :
Panel p = new Panel();
Button b = new Button();
p.add(b);

• De manière similaire, un composant est retirer de son conteneur

par la méthode remove() :
p.remove(b);

• Un composant a (notamment) :
une taille préférée que l’on obtient avec getPreferredSize()
une taille minimum que l’on obtient avec getMinimunSize()
une taille maximum que l’on obtient avec getMaximunSize()

-8-
Conteneurs et composants

import java.awt.*;
Création d’une fenêtre
public class EssaiFenetre1
(un objet de la classe
{
Frame) avec un titre
public static void main(String[] args)
{
Frame f =new Frame("Ma première fenêtre"); Création du bouton ayant
Button b= new Button("coucou"); pour label « coucou »
f.add(b);
f.pack(); Ajout du bouton dans la
f.show(); fenêtre
}
On demande à la fenêtre
}
de choisir la taille
minimum avec pack() et
de se rendre visible avec
show()
Layout

♦ Layout : contexte graphique pour le regroupement de composants GUI et la

gestion de leur affichage. Tout Container possède un layout manager ou
gestionnaire de positionnement, chargé, d'imposer une certaine disposition aux
composants qu'il reçoit.

• Les principaux gestionnaires de présentation de l'AWT sont :

FlowLayout, BorderLayout, GridLayout, CardLayout, GridBagLayout

- 10 -
Gestionnaire de présentation
■ Tout conteneur possède un gestionnaire de présentation par défaut.
 Tout instance de Container référence une instance de
LayoutManager.
 Il est possible d'en changer grâce à la méthode setLayout().
■ Les gestionnaires de présentation par défaut sont :
 Le BorderLayout pour Window et ses descendants (Frame, Dialog,
…)
 Le FlowLayout pour Panel et ses descendants (Applet, etc.)

■ Une fois installé, un gestionnaire de présentation fonctionne "tout seul" en

interagissant avec le conteneur.

- 11 -
 FlowLayout (1)

• Le FlowLayout est le plus simple des managers de l'AWT

• Gestionnaire de présentation utilisé par défaut dans les
Panel si aucun LayoutManager n'est spécifié.

• Un FlowLayout peut spécifier :

 une justification à gauche, à droite ou centrée,
 un espacement horizontal ou vertical entre deux composants.
 Par défaut, les composants sont centrés à l'intérieur de la zone
qui leur est allouée.

12
 FlowLayout (2)

• La stratégie de disposition du FlowLayout est la suivante :

 Respecter la taille préférée de tous les composants contenus.

 Disposer autant de composants que l'on peut en faire tenir
horizontalement à l'intérieur de l'objet Container.
 Commencer une nouvelle rangée de composants si on ne peut
pas les faire tenir sur une seule rangée.
 Si tous les composants ne peuvent pas tenir dans l'objet
Container, ce n'est pas géré (c'est-à-dire que les composants
peuvent ne pas apparaître).

13
FlowLayout (3)

Redimensionnement

Redimensionnement

14
FlowLayout (4)

Redimensionnement

Redimensionnement

15
 FlowLayout (5)
• Le FlowLayout cache réellement et effectivement les
composants qui ne rentrent pas dans le cadre.
• Le FlowLayout n'a d'intérêt que quand il y a peu de
composants.
• L'équivalent vertical du FlowLayout n'existe pas
• La présentation FlowLayout positionne les composants
ligne par ligne.
 Chaque fois qu'une ligne est remplie, une nouvelle ligne est
commencée.
• Le gestionnaire FlowLayout n'impose pas la taille des
composants mais leur permet d'avoir la taille qu'ils
préfèrent.
16
BorderLayout (1)
• BorderLayout divise son espace de travail en cinq
zones géographiques : North, South, East, West et
Center.
• Les composants sont ajoutés par nom à ces zones (un
seul composant par zone).
 Exemple
add("North", new Button("Le bouton nord !"));
 Si une des zones de bordure ne contient rien, sa taille est 0.

17
BorderLayout (2)
import java.awt.*;

public class EssaiBorderLayout extends Frame

{
private Button b1,b2,b3,b4, b5;
public EssaiBorderLayout() {
setLayout(new BorderLayout());
b1 = new Button ("Nord"); b2 = new Button ("Sud");
b3 = new Button ("Est"); b4 = new Button ("Ouest");
b5 = new Button ("Centre");
this.add(b1, BorderLayout.NORTH);
this.add(b2 , BorderLayout.SOUTH);
this.add(b3, BorderLayout.EAST);
this.add(b4, BorderLayout.WEST);
this.add(b5, BorderLayout.CENTER);
}
public static void main (String args []) {
EssaiBorderLayout essai = new EssaiBorderLayout();
essai.pack (); essai.setVisible(true) ;
}}

18
 BorderLayout (3)
• Stratégie de disposition du BorderLayout
 S'il y a un composant dans la partie placée dans la partie NORTH, il
récupère sa taille préférée, respecte sa hauteur préférée si possible et fixe sa
largeur à la totalité de la largeur disponible de l'objet Container.
 S'il y a un composant dans la partie placée dans la partie SOUTH, il fait
pareil que dans le cas de la partie NORTH.
 S'il y a un composant dans la partie placée dans la partie EAST, il récupère
sa taille préférée, respecte sa largeur préférée si possible et fixe sa hauteur
à la totalité de la hauteur encore disponible.
 S'il y a un composant dans la partie placée dans la partie WEST, il fait pareil
que dans le cas de la partie EAST.
 S'il y a un composant dans la partie CENTER, il lui donne la place qui
reste, s'il en reste encore.

19
BorderLayout (4)

• Lors du redimensionnement, le composant est lui-

même redimensionné en fonction de la taille de la
zone, c-à-d :
 les zones nord et sud sont éventuellement élargies mais pas
allongées.
 les zones est et ouest sont éventuellement allongées mais
pas élargies,
 la zone centrale est étirée dans les deux sens.

20
BorderLayout (5)

Redimensionnement

Redimensionnement

21
GridLayout (1)
• Le GridLayout dispose les composants dans une
grille.
 Découpage de la zone d'affichage en lignes et en colonnes
qui définissent des cellules de dimensions égales.
 Chaque composant à la même taille
 quand ils sont ajoutés dans les cellules le remplissage s ’effectue
de gauche à droite et de haut en bas.
 Les 2 paramètres sont les rangées et les colonnes.
 Construction d'un GridLayout : new GridLayout(3,2);

nombre de lignes nombre de colonnes

22
GridLayout (2)

import java.awt.*;
public class AppliGridLayout extends Frame
{
public AppliGridLayout()
{
super("AppliGridLayout");
this.setLayout(new GridLayout(3,2));
for (int i = 1; i < 7; i++)
add(new Button(Integer.toString(i)));
this.pack();
this.show();
}

public static void main(String args[])

{
AppliGridLayout appli = new AppliGridLayout();
}
}

23
GridLayout (3)

Redimensionnement

24
CardLayout
• Le CardLayout n'affiche qu'un composant à la fois :
 les composants sont considérées comme empilées, à la façon
d'un tas de cartes.
• La présentation CardLayout permet à plusieurs
composants de partager le même espace d'affichage de
telle sorte que seul l'un d'entre eux soit visible à la fois.
• Pour ajouter un composant à un conteneur utilisant un
CardLayout il faut utiliser add(String cle, Component
monComposant)
• Permet de passer de l ’affichage d ’un composant à un
autre en appelant les méthodes first, last, next, previous ou
show
25
GridBagLayout
• Le gestionnaire GridBagLayout fournit des fonctions de
présentation complexes
 basées sur une grille dont les lignes et les colonnes sont de taille
variables.
 permet à des composants simples de prendre leur taille préférée
au sein d'une cellule, au lieu de remplir toute la cellule.
 permet aussi l'extension d'un même composant sur plusieurs
cellules.
• Le GridBagLayout est compliqué à gérer.
 Dans la plupart des cas, il est possible d’éviter de l’utiliser en
associant des objets Container utilisant des gestionnaires
différents.
• Voir la doc

26
Mise en forme complexe

super("AppliComplexeLayout");
setLayout(new BorderLayout());
Panel pnorth = new Panel();
pnorth.add(b1); pnorth.add(b2);
pnorth.add(b3); pnorth.add(b4);
this.add(pnorth,BorderLayout.NORTH);

Panel pcenter = new Panel();

pcenter.setLayout(new GridLayout(2,2));
pcenter.add(gr1); pcenter.add(gr2);
pcenter.add(gr3); pcenter.add(gr4);
this.add(pcenter,BorderLayout.CENTER);

Panel psouth = new Panel();

psouth.setLayout(new FlowLayout());
psouth.add(ch); psouth.add(tf);
this.add(psouth, BorderLayout.SOUTH);

27
Récapitulatif
• FlowLayout
 Flux : composants placés les uns derrière les autres
• BorderLayout
 Ecran découpé en 5 zones (« North », « West », « South »,
« East », « Center »)
• GridLayout
 Grille : une case par composant, chaque case de la même
taille
• CardLayout
 « Onglets » : on affiche un élément à la fois
• GridBagLayout
 Grille complexe : plusieurs cases par composant
28
 Exemple d’une fenêtre JAVA
// Création de la fenêtre
JFrame frame = new JFrame("ExempleSimple");
// Création du container
JPanel panel = new JPanel();
// Définition du gestionnaire de placement
panel.setLayout(new GridLayout(1,2))
// Création des composants
JLabel label = new JLabel("Entrer votre nom");
JTextField textField = new JTextField("toto");
// Ajout des composants au container
panel.add(label);
panel.add(textField);
// Ajout du container à la fenêtre
frame.getContentPane().add(panel);
// Afficher la fenêtre
frame.pack();
frame.setVisible(true); 29
Les événements graphiques (1)
• L'utilisateur effectue
 une action au niveau de l'interface utilisateur (clic souris,
sélection d'un item, etc)
 alors un événement graphique est émis.
• Lorsqu'un événement se produit
 il est reçu par le composant avec lequel l'utilisateur interagit
(par exemple un bouton, un curseur, un champ de texte, etc.).
 Ce composant transmet cet événement à un autre objet, un
écouteur qui possède une méthode pour traiter l’événement
 cette méthode reçoit l’objet événement généré de façon à traiter
l'interaction de l'utilisateur.

30
Les événements graphiques (2)
• La gestion des événements passe par l'utilisation d'objets
"écouteurs d'événements" (les Listener) et d'objets
sources d'événements.
 Un objet écouteur est l'instance d'une classe implémentant
l'interface EventListener (ou une interface “fille”).
 Une source d'événements est un objet pouvant recenser des
objets écouteurs et leur envoyer des objets événements.
• Lorsqu'un événement se produit,
 la source d'événements envoie un objet événement
correspondant à tous ses écouteurs.
 Les objets écouteurs utilisent alors l'information contenue
dans l'objet événement pour déterminer leur réponse.

31
Les événements graphiques (3)
import java.awt.*;
import java.awt.event.*;

class MonAction implements ActionListener {

public void actionPerformed (ActionEvent e) {
System.out.println ("Une action a eu lieu") ;}
}

public class TestBouton {

public TestBouton(){
Frame f = new Frame ("TestBouton");
Button b = new Button ("Cliquer ici");
f.add (b) ;
f.pack (); f.setVisible (true) ;
b.addActionListener (new MonAction ());}

public static void main(String args[]) {

TestBouton test = new TestBouton();}
}

32
Les événements graphiques (4)

• Les écouteurs sont des interfaces

• Donc une même classe peut implémenter plusieurs interfaces
écouteur.
 Par exemple une classe héritant de Frame implémentera les
interfaces MouseMotionListener (pour les déplacements
souris) et MouseListener (pour les clics souris).
• Chaque composant de l’AWT est conçu pour être la source d’un
ou plusieurs types d'événements particuliers.
 Cela se voit notamment grâce à la présence dans la classe de
composant d'une méthode nommée addXXXListener().

33
Les événements graphiques (5)
• L’objet événement envoyé aux écouteurs et passé en
paramètres des fonctions correspondantes peut
contenir des paramètres intéressants pour l'application.

 Par exemple, getX() et getY() sur un MouseEvent

retournent les coordonnées de la position du pointeur de la
souris.
 Une information généralement utile quelques soit le type
d’événement est la source de cet événement que l’on obtient
avec la méthode getSource().

34
Modèle événementiel du JDK

♦ Le modèle événementiel de JDK 1.1 se compose :

• d'objets sources d'événements
• d'objets événements
• d'objets récepteurs d'événements

♦ Ces objets interagissent de façon standard en invoquant des méthodes pour

permettre le déclanchement et la gestion des événements

- 35 -
Catégories d'événements graphiques (1)
• Plusieurs types d'événements sont définis dans le
package java.awt.event.
• Pour chaque catégorie d'événements, il existe une
interface qui doit être définie par toute classe
souhaitant recevoir cette catégorie d’événements.
 Cette interface exige aussi qu'une ou plusieurs méthodes
soient définies.
 Ces méthodes sont appelées lorsque des événements
particuliers surviennent.

36
Catégories d'événements graphiques (2)
• ActionListener
 Action (clic) sur un bouton, retour chariot dans une zone de texte, « tic
d’horloge » (Objet Timer)
• WindowListener
 Fermeture, iconisation, etc. des fenêtres
• TextListener
 Changement de valeur dans une zone de texte
• ItemListener
 Sélection d’un item dans une liste
• FocusListener
 Pour savoir si un élément a le "focus"
• KeyListener
 Pour la gestion des événements clavier
37
Catégories d'événements graphiques (3)
• MouseListener
 Clic, enfoncement/relâchement des boutons de la souris,
etc.
• MouseMotionListener
 Déplacement de la souris, drag&drop avec la souris, etc.
• AdjustmentListener
 Déplacement d'une échelle
• ComponentListener
 Savoir si un composant a été caché, affiché …
• ContainerListener
 Ajout d'un composant dans un Container

38
Catégories d'événements graphiques (4)

Catégorie Nom de l’interface Méthodes

Action ActionListener actionPerformed (ActionEvent)
Item ItemListener itemStateChanged (ItemEvent)
Mouse MouseMotionListener mouseDragged (MouseEvent)
mouseMoved (MouseEvent)
Mouse MouseListener mousePressed (MouseEvent)
mouseReleased (MouseEvent)
mouseEntered (MouseEvent) (MouseEvent)
mouseExited
mouseClicked
Key KeyListener keyPressed (KeyEvent)
keyReleased (KeyEvent)
keyTyped (KeyEvent)
Focus FocusListener focusGained (FocusEvent)
focusLost (FocusEvent)

39
Catégories d'événements graphiques (5)

Adjustment AdjustmentListener adjustmentValueChanged

(AdjustmentEvent)
Component ComponentListener componentMoved
(ComponentEvent)componentHiddent
(ComponentEvent)componentResize
(ComponentEvent)componentShown
(ComponentEvent)
Window WindowListener windowClosing ( WindowEvent)
windowOpened ( WindowEvent)
windowIconified ( WindowEvent
windowDeiconified ( WindowEvent)
windowClosed ( WindowEvent)
windowActivated ( WindowEvent)
windowDeactivated ( WindowEvent)
Container ContainerListener componentAdded (ContainerEvent)
componentRemoved(ContainerEvent)
Text TextListener textValueChanged (TextEvent)

40
Catégories d'événements graphiques (6)

import java.awt.*;
import java.awt.event.*;
public class EssaiActionEvent1 extends Frame
implements ActionListener Implémentation de
{ l'interface ActionListener
public static void main(String args[])
{EssaiActionEvent1 f= new EssaiActionEvent1();} On enregistre
public EssaiActionEvent1() l’écouteur d’evt action
{ auprès de l’objet
super("Utilisation d’un ActionEvent"); source "b"
Button b = new Button("action");
b.addActionListener(this); Lorsque l'on clique
add(BorderLayout.CENTER,b);pack();show(); sur le bouton dans
} l ’interface, le titre de
public void actionPerformed( ActionEvent e ) la fenêtre change
{
setTitle("bouton cliqué !");
}}

41
Catégories d'événements graphiques (7)

public class EssaiActionEvent2 extends Frame

implements ActionListener
{ private Button b1,b2;
public static void main(String args[])
Les 2 boutons ont le
{EssaiActionEvent2 f= new EssaiActionEvent2();}
même écouteur (la
public EssaiActionEvent2(){
fenêtre)
super("Utilisation d’un ActionEvent");
b1 = new Button("action1"); e.getSource()" renvoie
b2 = new Button("action2"); l'objet source de
b1.addActionListener(this); l’événement. On
b2.addActionListener(this); effectue un test sur
add(BorderLayout.CENTER,b1); les boutons (on
add(BorderLayout.SOUTH,b2); compare les
pack();show(); } références)
public void actionPerformed( ActionEvent e ) {
if (e.getSource() == b1) setTitle("action1 cliqué");
if (e.getSource() == b2) setTitle("action2 cliqué");
}}

42
Catégories d'événements graphiques (8)

import java.awt.*; import java.awt.event.*;

public class WinEvt extends Frame
implements WindowListener
{ Implémenter cette
public static void main(String[] args) { interface impose
WinEvt f= new WinEvt();} l’implémentation de
public WinEvt() { bcp de méthodes
super("Cette fenêtre se ferme");
addWindowListener(this); La fenêtre est son
pack();show();} propre écouteur
public void windowOpened(WindowEvent e){}
public void windowClosing(WindowEvent e) WindowClosing() est
{System.exit(0);} appelé lorsque l'on
public void windowClosed(WindowEvent e){} clique sur la croix de
public void windowIconified(WindowEvent e){} la fenêtre
public void windowDeiconified(WindowEvent e){} "System.exit(0)"
public void windowActivated(WindowEvent e){} permet de quitter une
public void windowDeactivated(WindowEvent e){} } application java

43
Les adapteurs (1)
• Les classes « adapteur » permettent une mise en
œuvre simple de l'écoute d'événements graphiques.
 Ce sont des classes qui implémentent les écouteurs
d'événements possédant le plus de méthodes, en
définissant un corps vide pour chacune d'entre elles.
 Plutôt que d'implémenter l'intégralité d'une interface dont
une seule méthode est pertinente pour résoudre un
problème donné, une alternative est de sous-classer
l'adapteur approprié et de redéfinir juste les méthodes qui
nous intéressent.
 Par exemple pour la gestion des événements fenêtres...

44
Les adapteurs (2)

Solution en implémentant l’interface

class Terminator implements WindowListener
{
public void windowClosing (WindowEvent e) {System.exit(0);}
public void windowClosed (WindowEvent e) {}
public void windowIconified (WindowEvent e) {}
public void windowOpened (WindowEvent e) {}
public void windowDeiconified (WindowEvent e) {}
public void windowActivated (WindowEvent e) {}
public void windowDeactivated (WindowEvent e) {}
}

Solution en utilisant un WindowAdapter

class Terminator extends WindowAdapter
{
public void windowClosing (WindowEvent e) {System.exit(0);}
}

45
Les adapteurs (3)
• Il existe 7 classes d'adapteurs (autant que d'interfaces
d'écouteurs possédant plus d'une méthode) :
 ComponentAdapter
 ContainerAdapter
 FocusAdapter
 KeyAdapter
 MouseAdapter
 MouseMotionAdapter
 WindowAdapter

46
 Adaptateur d’événements
♦ WindowAdapter dans
package java.awt.event

♦ Étendre de la classe
WindowAdapter et
implémenter que la
méthode qui nous
concerne

- 47 -
Les composants graphiques (1)
• Button
• Canvas (zone de dessin)
• Checkbox (case à cocher)
• CheckboxGroup
• Label
• Choice (Sélecteur)
• List
• Scrollbar (barre de défilement)
• TextField (zone de saisie d’1 ligne)
• TextArea (zone de saisie multilignes)
48
Les composants graphiques (2)
• Button
 C'est un composant d'interface utilisateur de base de type
"appuyer pour activer".
 Il peut être construit avec une étiquette de texte (un label)
précisant son rôle à l'utilisateur.
 Un objet de la classe Button est une source d’ActionEvent
 Les écouteurs associés à des objets de la classe Button
doivent implémenter l’interface ActionListener
 Il n’y a qu’une méthode dans l’interface ActionListener,
c ’est la méthode
public void actionPerformed(ActionEvent e).
Button b = new Button ("Sample") ;
add (b) ;
b.addActionListener (...) ;
49
Les composants graphiques (3)
• CheckBox
 La case à cocher fournit un dispositif d'entrée "actif /
inactif" accompagné d'une étiquette de texte.
 La sélection ou la déselection est notifiée par un ItemEvent
à un écouteur implémentant l’interface ItemListener.
 la méthode getStateChange() de ItemEvent retourne une constante
: ItemEvent.DESELECTED ou ItemEvent.SELECTED.
 les méthode getItem() de ItemEvent renvoient la chaîne contenant
l'étiquette de la case à cocher considérée.

Checkbox one = new Checkbox("One", false);

add(one);
one.addItemListener(...);

50
Les composants graphiques (4)
• CheckboxGroup
 On peut regrouper des cases à cocher dans un
CheckboxGroup pour obtenir un comportement de type
boutons radio
 On ne peut sélectionner qu’une seule case du groupe de cases à
cocher en même temps.
 Sélectionner une case fera que toute autre case précédemment
cochée sera désélectionnée

CheckboxGroup cbg = new CheckboxGroup();

Checkbox one = new Checkbox("One", cbg, false);
...
add(one);
...

51
Les composants graphiques (5)
• Choice
 Ce composant propose une liste de choix.
 On ajoute des éléments dans l’objet Choice avec la méthode
addItem(String nomItem).
La chaîne passée en paramètre sera
la chaîne visible dans la liste
 On récupère la chaîne de caractère correspondant à l’item
actuellement sélectionné avec la méthode String
getSelectedItem()
 Cet objet est source de ItemEvent, l’écouteur correspondant étant
un ItemListener
Choice c = new Choice();
c.addItem("First");
c.addItem("Second");
...
c.addItemListener (...);

52
Les composants graphiques (6)
• Label
 Un Label affiche une seule ligne de texte (étiquette) non
modifiable.
 En général, les étiquettes ne traitent pas d'événements.

Label l = new Label ("Bonjour !");

add(l);

53
 Les composants graphiques (7)
• List
 Un objet de la classe List permet de présenter à l'utilisateur
plusieurs options de texte parmi lesquelles il peut sélectionner
un ou plusieurs éléments.
 Source d’ActionEvent et d’ItemEvent
 méthode String getSelectedItem() et String[] getSelectedItems()
pour récupérer des items.

List l =new List (4, false);

l.add("item1");

nombre d'items visibles sélections multiples possibles ou non.

(ici 4 éléments seront Ici, avec la valeur false, non possible
visible en même temps)

54
Les composants graphiques (8)
• TextField
 Le champ de texte est un dispositif d'entrée de texte sur
une seule ligne.
 Il est source d’ActionEvent
 On peut définir un champ de texte comme étant éditable
ou non.
 Méthodes void setText(String text) et String getText()
pour mettre ou retirer du texte dans le TextField
TextField f = new TextField ("Une ligne seulement ...", 30);
add(f);

Texte par défaut mis Nombre de caractères visibles

dans le TextField dans le TextField

55
Les composants graphiques (9)
• TextArea
 La zone de texte est un dispositif d'entrée de texte multi-
lignes, multi-colonnes avec éventuellement la présence ou
non de « scrollbars » (barres de défilement) horizontal
et/ou vertical.
 Il peut être ou non éditable.
 Méthode setText(), getText() et append() (pour ajouter du
texte à la fin d ’un texte existant déjà dans le TextArea)
TextArea t = new TextArea ("Hello !", 4, 30,TextArea.SCROLLBARS_BOTH);
add(t);

Valeur constante
Texte par défaut mis précisant la
dans le TextArea présence ou
Nombre de colonnes l’absence de
Nombre de lignes (en nbre de caractères) « scrollbar »

56
Création d’un menu (10)

♦ Ajouter à l ’application éditeur graphique un menu rudimentaire

♦ Classes utilisées:
• MenuBar: représente la barre de menu d’une fenêtre
• Menu: options visibles dans la barre de menu
• MenuItem:Items qui déclencheront par leur sélection des actions définies
par le programmeur

♦ La fenêtre joue le rôle de « Container »

dans lequel vont être disposés les
différents éléments constitutifs
(composants) de l ’interface graphique
de l’application (menu, boutons, listes
déroulantes, zone de saisie…)

- 57 -
Création d’un menu (11)

♦ Classes utilisées:
• MenuBar : représente la barre de menu d’une fenêtre
• Menu : options visibles dans la barre de menu
• MenuItem :éléments qui déclencheront par leurs
sélection des actions définies par le programmeur

- 58 -
Insertion du menu dans la fenêtre (12)

♦ Seule une instance de la classe Frame peut héberger un menu

♦ setMenuBar prend en paramètre une instance de la classe MenuBar :

• soit une instance directe de MenuBar qui aura été modifiée grâce aux méthodes add(…)
• soit une instance d ’une classe dérivée de MenuBar comme dans le cas présent

- 59 -
Les composants graphiques (13)
• Canvas
 Il définit un espace vide
 Sa taille par défaut est zéro par zéro (Ne pas oublier de la modifier
avec un setSize(...) ) et il n’a pas de couleur.
pour forcer un canvas (ou tout autre
composant) à avoir une certaine
taille il faut redéfinir les
méthodes getMinimumSize() et
getPreferredSize().
 On peut capturer tous les événements dans un Canvas.
 Il peut donc être associé à de nombreux écouteurs : KeyListener,
MouseMotionListener, MouseListener.
 On l’utilise en général pour définir une zone de dessin

60
Les composants graphiques (14)

class Ctrait extends Canvas implements MouseListener

{
Point pt;
public Ctrait() { addMouseListener(this); }
public void paint(Graphics g)
{g.drawLine(0,0,pt.x,pt.y);
g.setColor(Color.red);
g.drawString("("+pt.x+";"+pt.y+")",pt.x,pt.y+5);}
public Dimension getMinimumSize()
{return new Dimension(200,100);}
public Dimension getPreferredSize()
{return getMinimumSize();}
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e)
{pt=e.getPoint();repaint();}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}}

61
Les composants graphiques (15)
• Contrôle des couleurs d'un composant
 Deux méthodes permettent de définir les couleurs d'un
composant
 setForeground (Color c) : la couleur de l’encre avec laquelle on
écrira sur le composant
 setBackground (Color c) : la couleur du fond
 Ces deux méthodes utilisent un argument instance de la
classe java.awt.Color.
 La gamme complète de couleurs prédéfinies est listée dans la page
de documentation relative à la classe Color.
 Il est aussi possible de créer une couleur spécifique (RGB)
int r = 255, g = 255, b = 0 ;
Color c = new Color (r, g, b) ;

62
Les composants graphiques (16)

import java.awt.*; Utilisation de la classe précédente

import java.awt.event.*; (Ctrait) par une autre classe.
public class Dessin extends Frame Voir le fichier Dessin.java pour
{ voir la manière exacte dont les 2
public static void main(String[] args) classes sont définies et utilisées.
{
Dessin f= new Dessin();
}
public Dessin()
{
super("Fenêtre de dessin");
Ctrait c= new Ctrait();
add(BorderLayout.CENTER,c);
pack();
show();
}
}

63
Les composants graphiques (17)
• Contrôle des polices de caractères
 La police utilisée pour afficher du texte dans un composant
peut être définie avec setFont(...) avec comme argument
une instance de java.awt.Font.
 Font f = new Font ("TimesRoman", Font.PLAIN, 14) ;

 Les constantes de style de police sont en réalité des valeurs

entières, parmi celles citées ci-après :
 Font.BOLD
 Font.ITALIC
 Font.PLAIN
 Font.BOLD + Font.ITALIC

 Les tailles en points doivent être définies avec une valeur

entière.

64
Conteneurs particuliers (1)
• Dialog
 Un objet Dialog ressemble à un objet Frame mais ne sert
qu'à afficher des messages devant être lus par l'utilisateur.
 Il n'a pas de boutons permettant de le fermer ou de l'iconiser.
 On y associe habituellement un bouton de validation.
 Il est réutilisable pour afficher tous les messages au cours de
l'exécution d'un programme.
 Un objet Dialog dépend d'un objet Frame (ou héritant de
Frame)
 ce Frame est passé comme premier argument au constructeur).
 Un Dialog n'est pas visible lors de sa création. Utiliser la
méthode show() pour la rendre visible (il existe une
méthode hide() pour la cacher).

65
Conteneurs particuliers (2)
• FileDialog
 C’est une sous-classe de Dialog ; par défaut elle n’est pas
visible.
 C'est un dispositif de sélection de fichier : on peut préciser
si c’est en vue d’une sauvegarde ou du chargement d’un
fichier
 Un FileDialog ne gère généralement pas d'événements.
 Comme pour un objet Dialog, un FileDialog dépend d’un
objet Frame
 Un FileDialog est une fenêtre modale : à partir du moment
ou la fenêtre a été rendue visible par la méthode show(...),
la main n’est rendu à l’utilisateur que quand un fichier a
été sélectionné.
66
Conteneurs particuliers (3)
• FileDialog

67
Conteneurs particuliers (4)
• ScrollPane
 C'est un conteneur général de type Panel
 tout comme un Panel il ne peut pas être utilisé de façon
indépendante
 il fournit des barres de défilement (scrollbars) verticales et/ou
horizontales
 Un ScrollPane ne peut contenir qu'un seul composant
 Ce conteneur n’est pas très intéressant mais est cité pour
information.
• Avec Swing que nous allons voir dans la suite, ne
nouveaux très intéressants composants font leur
apparition...

68
Swing
Swing vs Awt
♦ Les classes de la bibliothèque AWT sont écrites en code natif du système qui
accueille java. On parle alors de composants lourds. Quoiqu’elle présente
l’avantage d’être plus rapide en affichage

♦ Les composants légers sont, quant à eux, des composants écrits entièrement en
Java. La bibliothèque Swing n’offre que des composants légers

♦ Swing, en fait, triche un peu. Ses composants dérivent pour la plupart de Component
de AWT ce qui assure en fait le lien avec le système d’affichage natif de la plate-
forme utilisée

♦ Swing garantit une apparence uniforme de l’application entre les différentes plates-
formes

♦ Swing possède une fonctionnalité assez avancé, appelée le “pluggable look and
feel “ qui signifies que l’apparence de l’interface utilisateur peut être modifié
dynamiquement pour s’adapter aux habitudes de l’utilisateur travaillant sur une
plateforme et OS différents

- 70 -
Conversion de AWT vers Swing

♦ La bibliothèque Swing a été conçue pour permettre une conversion « relativement »

aisé des applications écrites à l’aide d’awt. Dans bien des cas il suffit d ’ajouter un
‘ J ’ au nom des classes des composants awt

- 71 -
Ajout d’un composant à une fenêtre

- 72 -
Composants graphiques Swing
♦ Hiérarchie très partielle des classes couvrant les composants des swings

- 73 -
Imbrication des composants
♦ Utilisation de JPanels Pour structurer l’interface graphique. Par exemple,
l’ajout d ’une barre d’outils à l’éditeur graphique

- 74 -
Principaux paquetages Swing (1)
• javax.swing
 le paquetage général
• javax.swing.border
 pour dessiner des bordures autour des composants
• javax.swing.colorchooser
 classes et interfaces utilisées par le composant
JColorChooser
• javax.swing.event
 les événements générés par les composants Swing
• javax.swing.filechooser
 classes et interfaces utilisées par le composant
JFileChooser

75
Principaux paquetages Swing (2)

• javax.swing.table
 classes et interfaces pour gérer les JTable
• javax.swing.text
 classes et interfaces pour la gestion des composants
« texte »
• javax.swing.tree
 classes et interfaces pour gérer les JTree
• javax.swing.undo
 pour la gestion de undo/redo dans une application

76
 JFrame
• Ancêtre commun : classe JComponent
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent

• Le JFrame
 Un objet JFrame a un comportement par défaut associé à une
tentative de fermeture de la fenêtre.
 Contrairement à la classe Frame, qui ne réagissait pas par défaut,
l'action de fermeture sur un JFrame rend par défaut la fenêtre invisible.
 Ce comportement par défaut peut être modifié par
setDefaultCloseOperation().

77
JFrame
• 4 comportements sont possibles lors de la fermeture de la fenètre
• DO_NOTHING_ON_CLOSE
• HIDE_ON_CLOSE
• DISPOSE_ON_CLOSE
• EXIT_ON_CLOSE
import javax.swing.*;
public class Simple {
public static void main(String[] args) {
JFrame cadre = new JFrame("Ma fenetre");
cadre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
cadre.setSize(300, 200);
cadre.setVisible(true);
}
} détermine que l’application sera terminée
Lorsqu’on fermera la fenêtre

78
JFrame
Le conteneur d'un JFrame n'est plus confondu avec le cadre lui-même.
Il possède une couche de contenu, dans laquelle on peut ajouter les
composants graphiques et dont on peut changer le gestionnaire de
présentation.
Cette couche est obtenue par la méthode getContentPane();

Avec AWT
Frame monFrame = new Frame ("Mon Frame");
Button monBouton = new Button ("Mon Bouton");
monFrame.add(monBouton);

Avec Swing
JFrame monFrame = new JFrame ("Mon Frame");
JButton monBouton = new JButton ("Mon Bouton");
Container panneauContenu = monFrame.getContentPane();
panneauContenu.add(monBouton);

79
Quelques composants Swing (3)
• La classe ImageIcon et l’interface Icon
 Les objets de cette classe permettent de définir des icônes
à partir d’images (gif, jpg, etc.) qui peuvent être ajoutés au
classique texte d'un JLabel, d'un JButton, etc.

Icon monIcone = new ImageIcon("Image.gif");

// Un JLabel
JLabel monLabel = new JLabel("Mon Label");
monLabel.setIcon(monIcone);
monLabel.setHorizontalAlignment(JLabel.RIGHT);

// Un JButton
JButton monBouton = new JButton("Mon bouton", monIcone);

80
Quelques composants Swing (4)
• JTextPane
 un éditeur de texte qui permet la gestion de texte formaté,
le retour à la ligne automatique (word wrap), l'affichage
d'images.
• JPasswordField
 un champ de saisie de mots de passe : la saisie est invisible
et l'affichage de chaque caractère tapé est remplacé par un
caractère d'écho (* par défaut).
• JEditorPane
 un JTextComponent pour afficher et éditer du code
HTML 3.2 et des formats tels que RTF.

81
Exemple de JEditorPane
import javax.swing.*;
import java.awt.*;
public class EditeurWEB {
public static void main(String[] args)
{
JFrame monFrame = new JFrame ("Mon Frame");
monFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try {
JEditorPane monEditeur = new
JEditorPane("http://www.google.fr");
Container panneauContenu = monFrame.getContentPane();
panneauContenu.setLayout(new FlowLayout());
panneauContenu.add(monEditeur);
monFrame.pack();
monFrame.show();}
catch (Exception e) {System.out.println(e.getMessage());};
} }

82
Quelques composants Swing (5)
• Des bordures peuvent être dessinées autour de tous
composants graphiques. Swing en définit 9 types :
 AbstractBorder : ne fait rien
 BevelBorder : une bordure 3D en surépaisseur ou en creux
 CompoundBorder : permet de composer des plusieurs bordures
 EmptyBorder
 EtchedBorder
 LineBorder : bordures d'une seule couleur)
 MatteBorder
 SoftBevelBorder : une bordure 3D aux coins arrondis
 TitledBorder : une bordure permettant l'inclusion d’une chaîne de
caractères

83
Quelques composants Swing (6)
• JLayeredPane
 un conteneur qui permet de ranger ses composants en
couches (ou transparents).
 Cela permet de dessiner les composants, selon un certain
ordre: premier plan, plan médian, arrière plan, etc.
 Pour ajouter un composant, il faut spécifier la couche sur
laquelle il doit être dessiné
monJlayeredPane.add (monComposant, new Integer(5));
 des « layer » sont définis en natif et des constantes pour y accéder
existent dans la classe.

84
Quelques composants Swing (7)
• ToolTipText
 permet de créer des aides en lignes qui apparaissent
lorsque la souris passe sur un composant.
JButton monBouton = new JButton ("Un bouton");
monBouton.setToolTipText ("Aide de mon bouton");

• Représenter des listes : classe JList

• Représenter des arbres : classe JTree
• Représenter des tables (Excel) : classe JTable
• Ces quelques nouveautés ne sont qu'un aperçu de ce
que propose Swing.
 Il y a beaucoup de composants, de nouveaux gestionnaires
de présentation, de nouveaux événements graphiques que
l’on ne peut présenter et détailler dans le cadre de ce cours.

85