Karim AFDEL

1- Introduction
 Dans ce cours nous intéresser à la mise en œuvre
d’interfaces graphiques en Java.
 Comme nous allons le voir, il vous est possible de créer
toutes sortes d'interfaces, et d'y inclure tous types de
composants : des boutons, des cases à cocher, des zones
de saisie de texte, ...etc.
 Ou peut y inclure des composants plus complexes : des
menus, des arbres déroulant, des list, des boîtes de
dialogue pour choisir des fichiers, des couleurs;
 Mais avant d'aller plus loin il nous faut être capable de
faire un choix. En effet, deux API de définition
d'interface graphique vous sont proposées : l'Abstract
Window Toolkit (l'AWT) et Swing.
 Chaque fois que l'utilisateur interagit avec un composant, un
événement est envoyé à l'application
 Différents événements sont envoyés à différentes parties de
l'application
1.1 L'Abstract Window Toolkit (l'AWT)
 L'Abstract Window Toolkit AWT est historiquement la première
qui vous fut proposée. Dès le JDK 1.0, vous pouviez déjà l'utiliser.
 La contrainte de l'AWT, ou l'avantage (c'est à double tranchants),
c'est que Java fait appel au système d'exploitation sous-jacent
pour afficher les composants graphiques.
 Pour cette raison, l'affichage de l'interface utilisateur d'un
programme peut diverger sensiblement : chaque système
d'exploitation dessine à sa manière un bouton. Attention, l'AWT
garantie que la fonctionnalité recherchée sera dans tous les cas
fournie (mais présentée différemment).
 Or Java se veut être 100% indépendant de la plate-forme utilisée !
Pas 99%.
 Pour cette raison, une nouvelle API (Swing)fut définie. Mais
hormis ce détail d'affichage, l'AWT présente un avantage
indéniable : en utilisant les objets graphiques de l'OS.
1.2 Swing
 SWING fut donc mis en place pour assurer 100% de portabilité (même un pixel
doit avoir la même couleur).
 Le pari est gagné, mais à un coup non forcément négligeable : pour assurer
cette portabilité, un bouton (au tout autre composant graphique) est dessiner
non plus par l'OS, mais par Java (ce qui en terme de temps d'exécution à un
prix).
 En fait, SWING est présenté comme étant écrit uniquement en Java. Bien
entendu, il y a une petite triche : en effet, Java doit au moins être capable
d'interagir avec l'OS pour pouvoir tracer un point (il faut donc autre chose que
du 100% Java). Or c'est ce que font les classes de base de l'AWT (telles que
Component, Container, ...). En conséquence, tous les composants de SWING
dérive d'une classe de l'AWT.
Note !!!
 les mécanismes de gestion d'événements et de positionnent des composants de
l'AWT restent utilisable avec SWING. Donc, certaines clàsses déjà utilisées avec
l'AWT sont donc toujours d'actualité.
 En terme d'importation de package, cela implique qu'un programme SWING
doit malgré tout importer certains packages de l'AWT.
 Swing est bien plus riche que l'AWT (même si un composant n'existe pas en
natif sur l'OS, rien n'empêche de complètement le redessiner)
13-L'Abstract Window Toolkit a'AWT)
 Commencant par étudier l'un des packages les plus apprécié de Java : le
package java.awt.
 Ce package propose un certain nombre de fonctionnalités qui vont vous
permettre de créer très simplement des interfaces graphiques.
 D’autres mécanisais mis à notre disposition pour gérer les événements
tel un clic souris par exemple.
 Les diverses natures d'objets graphiques
Nous avons à notre disposition principalement trois types d'objets :
 les Components qui sont des composants graphiques,
 Les Containers qui contiennent les Components (attention un Container
est aussi un Component)
 Les Layouts qui sont en fait des stratégies de placement de Components
pour les Containers.
Conteneurs
 Tous les conteneurs dérivent de la classe Container. Nous y trouvons
notamment les classes :
 Panel,
 Frame
 Applet.
 Un Panel est un conteneur que l'on peut placer dans un autre conteneur. Une
Frame est une fenêtre à part entière. Nous reviendrons sur la classe Applet dans
le chapitre suivant.
 On trouve notamment les méthodes add et remove qui permettent d'ajouter et
de supprimer des composants d'un conteneur.
 L’exemple suivant créer une Frame dans laquelle on place un bouton.

import ava.awt.*; public

class Essai AWT{
public static void main(String argv[]) {
Frame f = new Frame("Fenetre") ;
Button b =new Button ("Push me") ;
f.add(b);//On place le bouton dans la frame
f.pack();// ajuste la frame
f.show();} / / affichage
Les Frames
 Un objet de classe Frame permet donc de créer une fenêtre.
 Toutes applications graphiques commencent donc par créer
une Frame.
 On disposg notamment des méthodes
 show (pour afficher la fenêtre),
 hide (pour l'effacer),
 setTitle (pour fixejrlon .titre),
 setMenuBar (pour y fixer une barre de menu),
 setSize (pour changer sa taille),
 setLayout (pour fixer une stratégie de placement des
composants), pack (pour la réduire à sa taille m
 Si l'on excepte les conteneurs, il nous reste alors des
composants tels des boutons (la classe Button), des labels
(la classe Label), des zones de saisies de texte (les classes
TextField et TextArea), les zones
 import java.awt.*; public class EssaiAwt2 {
public static void main(String argv[])
{ Frame f = new Frame("Fenetre");
f.setLayout(new FlowLayout());//Stratégie de placement des objets
Button bl=new Button("Boutonl");//Créer un objet bouton
CheckboxGroup cbg = new CheckboxGroup();//Créer un objet groupe de cases à
cocher
Checkbox cb1= new Checkbox ( « Check Box 1 ", cbg, false ) ;
//Créer un objet case à cocher appartenant au groupe cbg
Checkbox cb2 = new Checkbox("Check Box 2",cbg,false);
cb1.setState(true);//la case à cocher cb1 activée
Choice ch = new Choice(); //Objet liste de choix
ch.addltem("Informatique”);//option de la liste .
ch.addltem("Consommable");
ch.addltem("Entretien");
f.add(ch); f.add(bl);f.add(cbl);f.add(cb2);
// Ajouter les 4 objets à la feuille
f.pack(); // On ajuste la frame
f.show(); // Et on l’affiche
}
}
 La gestion des événements en Java
 Le langage Java propose un mécanisme clairement établit pour le
traitement d’événements.
 Ce mécanisme repose sur la notion de "Listener" (écouteurs).
 Ce qu’il faut aussi savoir, c'est que ce mécanisme de gestion d'événements
n'est, en fait, pas directement rattaché à une quelconque API d'interface
graphique. Au contraire, il se veut indépendant de tout contexte. On peut
donc traiter les événements Java en réponse à des clicks souris, mais aussi
en réponse à tout autre activité se déroulant au sein de la JVM.
 Bien entendu, en Java, tout est objet. En conséquence, les événements
sont aussi des objets.
 D'ou deux classes particulières :
 java.util.EventObject : correspond à la classe d'événements la plus
générique (elle dérive directement de javadang.Object.
 java.awt.AWTEvent: dérive tous les événements le l'AWT et de Swing :
c'est donc la classe mère des événements d'interfaces utilisateurs.
 La classe java.util.EventObject possède une méthode fort intéressante :
 getSource() : permet de récupérer l'objet sur lequel l'événement est
initialement apparut. En conséquence, quand vous traiterez un
événement, vous pourrez toujours savoir quel est l'objet initiateur du
traitement.
 Traitemment des événements necessite, au moins, d’importer deux
packages : java.awt.* et java.awt.event.*;
Traitement d’événements simples

comment savoir qu'un événement a e u lieu, et comment allions nous pouvoir y répondre?
1-définir un écouteur,
2- enregistrer ce dernier sur un objet susceptible de déclencher un événement. Ainsi, si l'événement
apparaît, il pourra être traité par l'écouteur.

Définition d’un écouteur

Dans le modèle Java de traitement d'événements, il nous faut définir un écouteur.
 Un écouteur est un objet qui possède au moins une méthode qui pourra être invoquée si l'événement
attendu apparaît. En fait, un écouteur doit remplir un contrat bien particulier. Dans cet objectif, il se doit
d'implémenter un comportement (la plupart du temps en implémentant une interface, ou bien en
dérivant de certaines classes).

 Plusieurs types d'écouteurs, donc plusieurs types d'interfaces. Toutes ces interfaces ont un nom se
terminant par Listener (par exemple ActionListener, WindowListener, ...). Selon l'interface, il y a une ou
plusieurs méthodes à implémenter.
A titre d'exemple :
 considérons l'événement ActionEvent : cet événement est déclenché dès lors que l'on action un bouton
(par exemple) soit en cliquant dessus avec la souris soit en utilisant le clavier. Pour être capable d'écouter
et de traiter un tel événement, un objet écouteur se doit d'implémenter une
 interface nommée ActionListener. Si vous êtes curieux et que vous étudier l'interface ActionListener,
vous remarquerez qu'elle ne contient qu'une unique méthode à implémenter : actionPerformed. Cette
méthode doit donc contenir le code à exécuter si jamais vous cliquez sur votre bouton.
 chaque écouteur doit être enregistré auprès des objets qu'il est censé écouter (un écouteur peut écouter
plusieurs sources d'événements - une source d'événement peut alerter plusieurs écouteurs).
L'exemple suivant enregistre l'écouteur à une source d'événements.
import j ava.awt.* ;
import j ava.awt.event.* ;
public class TestEvent implements ActionListener { Qu'a permit de faire la
Button bl=newButton("Enregistrer"); méthode addActionListener ?
Button b2=newButton("Anuuler"); 1 - Rajouter un écouteur au
Button b3=newButton("Quiter");
bouton.
Label mes=new Label("Etat de clic ");
2 - A chaque fois que le bouton
public TestEvent () {
Frame f = new Frame("Ma fenêtre"); est actionné, il cherche
f.setBounds(10,10,4 00,4 00 ) ; maintenant à invoquer la
f.setLayout(new FlowLayout()); méthode actionPerformed sur
chacun de ses écouteurs.
bl.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);

f.add(bl);_ // On ajoute le bouton dans la fenêtre

f.add(b2) ; f.add(b3); f.add(mes); f.setVisible(true);}
static public void main(String argv[]) {
new TestEvent ();}

// gestionnaire d'événement définit dans ActionListener

public void actionPerformed(ActionEvent e) {
if (e.getSource()==bl) mes.setText("Enregistrement"); else
if(e.getSource()==b2) mes.setText("Annulation");
else if(e.getSource()==b3)
System.exit(0);}}
 Définition de classes privées
Une première solution consiste à définir des classes privées
simplement dédiées au traitement des l'évènements. Deux façons de coder peuvent être retenue.
import j ava.awt.* ;
import j ava.awt.event.* ;
public class TestEvent {
Button bl=newButton("Enregistrer");
Button b2=newButton("Anuuler");
Button b3=newButton("Quiter"); ■
Label mes=new LabelC'Etat de clic ");
//Classe interne qui gère qui répond aux événements
class Handler implements ActionListener{
// gestionnaire d'événement définit dans ActionListener
public void actionPerformed(ActionEvent e) {
if (e.getSource()==bl)
mes.setText("Enregistrement"); else if(e.getSource0==b2) mes.setText("Annulation"); else if(e.getSource()==b3)
System.exit(0);}}
static public void main(String argv[]) { new TestEvent ();}
// Le constructeur public TestEvent (){
Frame f = new Frame("Ma fenêtre");
f.setBounds(10,10,400,400);
f.setLayout(new FlowLayout());
Handler ecouteur =new Handler ();
bl.addActionListener(ecouteur);//Enregistrer l’écouteur pour bl
b2.addActionListener(écouteur);//Enregistrer l'écouteur pour b2
b3.addActionListener(écouteur);
f.add(bl); // On ajoute le bouton dans la fenêtre
f.add(b2); f.add(b3); f.add(mes); f.setvisible(true);}
}
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().
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().
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
é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.
Catégories d'événements graphiques (2)

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)
Catégories d'événements graphiques (3)

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)
Catégories d'événements graphiques (4)
 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
Catégories d'événements graphiques (5)

 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
Catégories d'événements graphiques (6)

 FocusListener
 Pour savoir si un élément a le "focus"
 KeyListener
 Pour la gestion des événements clavier
Catégories d'événements graphiques (7)

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 l’écouteur
public EssaiActionEvent1()
d’evt action auprès de
{ l’objet source "b"
super("Utilisation d’un ActionEvent");
Button b = new Button("action");
b.addActionListener(this); Lorsque l'on clique sur le
add(BorderLayout.CENTER,b);pack();show(); bouton dans l ’interface,
} le titre de la fenêtre
public void actionPerformed( ActionEvent e ) change
{
setTitle("bouton cliqué !");
}}
Catégories d'événements graphiques (8)
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é");
}}
Catégories d'événements graphiques (9)

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

public class WinEvt extends Frame
implements WindowListener
{ Implémenter cette interface
public static void main(String[] args) { impose
l’implémentation de bcp de
WinEvt f= new WinEvt();} méthodes
public WinEvt() {
super("Cette fenêtre se ferme");
addWindowListener(this); La fenêtre est son propre
écouteur
pack();show();}
public void windowOpened(WindowEvent e){}
public void windowClosing(WindowEvent e) WindowClosing() est appelé
{System.exit(0);} lorsque l'on clique sur la
public void windowClosed(WindowEvent e){} croix de la fenêtre
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){} "System.exit(0)"
public void windowActivated(WindowEvent e){} permet de quitter une
public void windowDeactivated(WindowEvent e){} } application java
Les classes d’adaptation
 Dans les exemples précédents, les choses étaient simples : l'interface
utilisée ne définie qu'une seule méthode.
Mais en est-il de même pour les autres types d'événements ?
Réponse : Et bien non. Les événements de fenêtre en sont un bon exemple
: en effet une seule interface est définie pour tous ce qui peut arriver sur
une fenêtre (ouverture de fenêtre, fermeture, iconification, ...). Au
total, ce sont sept méthodes qui y sont définies. Or, n'oublions pas
qu'en implémentant une interface, vous vous devez d'implémenter
chacune de ses méthodes (sans quoi votre classe est abstraite) et ce
même si certaines ne vous sont pas utile (vous ne vouliez réagir qu'à la
fermeture de la fenêtre).
 Une classe d'adaptation est une classe qui implémente une interface en
fournissant, pour chaque méthode, un corps vide. L'intérêt est évident :
si vous avez besoin de fournir du code pour une unique méthode de
l'interface, vous ne devrez donner, dans la définition de la classe
anonyme, que le code de cette méthode. Pour les autres, elles sont déjà
implémentées, même si leur code est inexistant (un corps vide { }).
 Une petite remarque : toutes les classes d'adaptation ont sensiblement
le même nom que leur interface associée. Il suffit de remplacer le mot
'Listener' par 'Adapter'. Ainsi l'interface WindowListener possède une
classe associée, nommée WindowAdapter.
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...
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);}
}
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
Les adapteurs (4)

 En pratique, et notamment avec la classe

WindowAdapter, on utilise très souvent une
classe anonyme

Frame f = new Frame("Machin")

f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e)
{
System.exit(0);
} });
Conteneur Panel
 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 Panel sont créés et ajoutés aux autres conteneurs de la
même façon que les composants tels que les boutons
 Les Panel peuvent ensuite redéfinir une présentation qui
leur soit propre pour contenir eux-mêmes d'autres
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()
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()
 Les Gestionnaires de présentation

 A chaque conteneur est associé un gestionnaire de présentation

(layout manager)
 Le gestionnaire de présentation gère le positionnement et le
(re)dimensionnement des composants d’un conteneur.
 Le ré-agencement des composants dans un conteneur a lieu
lors de :
 la modification de sa taille,
 le changement de la taille ou le déplacement d'un des
composants.
 l'ajout, l'affichage, la suppression ou le masquage d'un
composant.
 Les principaux gestionnaire de présentation de l'AWT sont :
FlowLayout, BorderLayout, GridLayout, CardLayout,
GridBagLayout
 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 fonctionne "tout seul" en

interagissant avec le conteneur.
 Gestionnaire de Présentation : FlowLayout

 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.
 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).
FlowLayout (3)

OK Ouvrir Redimensionnement Ouvrir Fermer

OK
Fermer

plus visible

OK Ouvrir Redimensionnement
OK Ouvrir Fermer
Fermer
FlowLayout (4)

Redimensionnement

Redimensionnement
FlowLayout (5)

Redimensionnement

Redimensionnement
FlowLayout (6)
 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.
 Gestionnaire de présentation : BorderLayout

 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.
BorderLayout (2)

 Division de l’espace avec le BorderLayout

NORTH

WEST CENTER EAST

SOUTH
BorderLayout (3)
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) ;
}}
 BorderLayout (4)
 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.
BorderLayout (6)
 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.

N N
Redimensionnement
O C E
O C E
S

S
BorderLayout (7)

Redimensionnement

Redimensionnement
Gestionnaire de présentation : 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

GridLayout (3)
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();
}
}
GridLayout (4)

 Lors d’un redimensionnement les composants changent tous de

taille mais leurs positions relatives ne changent pas.

1 2 Redimensionnement 1 2

3 4 3 4
5 6 5 6
GridLayout (5)

Redimensionnement
Mise en forme complexe (1)

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);
D’autres gestionnaires?
 On peut imposer à un objet « container » de n’avoir pas de
gestionnaire en fixant son LayoutManager à la valeur null
 Frame f = new Frame(); f.setLayout(null);
 A la charge alors du programmeur de positionner
chacun des composants « manuellement » en indiquant
leur position absolue dans le repère de la fenêtre.
 C’est à éviter, sauf dans des cas particuliers,.
 Il est possible d’écrire ses propres LayoutManager…
Récapitulatif gestionnaire de présentation

 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
Hiérarchie de la librairie AWT

 La classe JComponent est la classe

fil de la classe container et est
constitue la classes base de Swing
 La classe JFrame est la classe fil de la
classe Frame de l'AWT.
 La classe JApplet est dérivé de la
classe Applet fréquemment utilisée
de l'AWT
 Button, Canvas, et Container sont
des classes AWT fils de la classe
abstrait Component
AWT et Swing 56
AWT et Swing 57
AWT et Swing 58
AWT et Swing 59
Conteneur

AWT et Swing 60
AWT et Swing 61
 Conteneurs spécifiques

AWT et Swing 62
Fenêtres

AWT et Swing 63
AWT et Swing 64
Boites de dialogues spécifiques

AWT et Swing 65
Applets

AWT et Swing 66
Menus

AWT et Swing 67
La Classe JComponent
 Les Frames « Fenêtres »

 La plupart des programmes d'interface graphique sont créés à

partir (dérivant) de la classe de base JFrame

 Une Frame est un container objet, donc les composants GUI

peuvent être placés dedans

 un objet Frame est réellement une zone de mémoire principale

qui tient des informations et des méthodes

Classe javax.swing.JFrame
Le conteneur principal d’ une application Swing est la classe JFrame•
JRootPane (Panneau Racine) lui même est un conteneur de plusieurs •
panneaux enfants
Le JRootPane contient les éléments suivants :
•glassPane (un JPannel par défaut)
•layeredPane (un JLayeredPane)
•contentPane (un JPannel par défaut)
•menuBar (un JMenuBar null par défaut)

contentPane est un panneau créé par défaut, il reçoit les composants

à l’aide de l’instruction suivante :
maJFrame.getContentPane().add(monComponent)
Méthodes utiles de la classe JFrame
 getContentPane() retourne le contentPane de la fenêtre
 setDefaultCloseOperation(int) spécifie l’action de fermeture par défaut
 setJMenuBar() attribue un Menu à cette fenêtre
 setLayout() attribue un Layout ( doit être utilisée par le contentPane)
 setVisible(boolean) affiche ou fait disparaître la fenêtre (remplace les
méthodes show() et hide())
 setTitle(String) attribue un titre à la fenêtre
 setSize(int, int) attribue des dimensions à la fenêtre
Exemple
import java.awt.*;
import javax.swing.*;
public class TestFrame1{
public static void main ( String[] args )
{ JFrame frame = new JFrame("Test Frame
1");//création d’un objet frame
frame.setSize(200,100);// crée un cadre
rectangulaire de taille 200x100 pixel
frame.setVisible( true ); // affiche ce cadre
}
Exemple2
import java.awt.*;
import javax.swing.*;
class myFrame extends JFrame
{
public void paint ( Graphics g )
{ // draw a String at location x=10 y=50
g.drawString("A myFrame object", 10, 50 );
}}
public class TestFrame2
{ public static void main ( String[] args )
{ myFrame frame = new myFrame();

frame.setSize( 150, 100 );

frame.setVisible( true ); }}
 Boutons Radio
 La classe qui traite les boutons Radio : JRadioButton
 JRadioButton est une classe dérivée de la classe JAbstractButton
 Les boutons Radio doivent être membres d'un ButtonGroup
 Seul un bouton du ButtonGroup doit être sélectionné à la fois
 Quand un bouton est sélectionné les autres sont désactivés

 Création d’un objet JRadioButton :

JRadioButton( String text, boolean selected )
Text : est l’étiquette du bouton radio
Selected : pour la sélection du bouton radio

 setActionCommand(String) et addActionListener(ActionEvent)
peuvent être utiliser pour prendre en compte des actions
évènements.
Création d’objets boutons Radio
 SexeMasculin = new JRadioButton("Male", true );
 SexeFeminin = new JRadioButton("Female", false );

Création du groupe bouton

 genderGroup = new ButtonGroup();

Intégration des bouttons dans le groupe Bouton : genderGroup

 genderGroup.add( genderM );
 genderGroup.add( genderF );
 Combox
La classe qui traite les Combox : JCombox 
Création d’objets panneau
JPanel chPanel=new JPanel(new FlowLayout.LEFT)); 
Création d’objets boutons Radio
Ch=new JComboBox(); 
Intégration des Items dans Combox
ch.addItem(« solaris »);
ch.addItem(« Linux »);
ch.addItem(« MacOs »);
 Listes

 JListe prend ses données dans un ListModel. Un vecteur en est un, mais
tout tableau d’objets (Object [ ]) est accepté dans un constructur.
 JPanel lsPanel=new JPanel(New FlowLayout(FlowLayout.LEFT);
 String[] donnees=
{"Motif","AWT","Windows","Swing","Xwindows","Gnome"};
 JList ls=new JList(donnees);
 lsPanel.add(new JScrollPane(ls));
 getContentPane().add( lsPanel );
Ajouter et Supprimer dans une liste

 On ajoute au modèle
Jlist ls ….
ls.getModel().addElement(string);// ajout à la fin de la liste
Ls.getModel().add(position, string);
 On recherche du modèle:
Jlist ls….
ls.getModel().remove(position);
 On récupère les positions sélectionnées par :
Int [] position =ls.getSelectionIndices();
Int position = ls.getSelectedIndex();
Objet [] values=ls.getSelectionValues();
Objet value=ls.getSelectedValue();
 Boutons à cocher

 La classe qui traite les Checkbox : JCheckbox

 De nombreuses bordures existent( importer
Javax.swing.border.*;
Instance Objet JChecbox
 JCheckBox cbSolaris, cbLinux, cbMacOs;
Intégration d’objet dans le panneau cbPanel
 JPanel cbPanel =new JPanel(new FlowLayout());
cbPanel.add(cbSolaris=new JCheckBox("Solaris"));
cbPanel.add(cbLinux=new JCheckBox("Linux"));
cbPanel.add(cbMacOs=new JCheckBox("MacOs"));
 Lecture des valeurs

 Public void actionPerformed(ActionEvent e)

{if (e.getActionCommand().equals(« quitter »)) System.exit(0):
//bouton
//texte : getText()
System.out.println(« textefield ‘ + tf.getText());
// Combox: getSelectionItem()
System.out.println(«Combox ‘ + ch. getSelectionItem());
//liste : getSelectionValue()
System.out.println(«liste ‘ + ls. getSelectionValue());
//Checkbox : isSelected()
System.out.println(«Checkbox‘ + cbSolaris. isSelected());
//Radio : group.getSelection().getActionCommand());
System.out.println(«Radio‘ + rbgroup.getSelection().getActionCommand());
 JTextArea
 La classe JTextArea est un composant qui permet la saisie de texte
simple en mode multi-lignes
 JTexteArea propose plusieurs méthodes pour ajouter du texte dans son
modèle :
 soit fournir le texte en pramètre du constructeur utilisé
 soit utiliser la méthode setText() qui permet d'initialiser le texte du
composant
 soit utiliser la méthode append() qui permet d'ajouter du texte à la
fin de celui contenu dans le texte du composant
 soit utiliser la méthode insert() permet d'insérer un texte à une
position données en caractères dans dans le texte du composant
 La méthode replaceRange() permet de remplacer une partie du
texte désignée par la position du caractère de début et la
position de son caractère de fin par le texte fourni en paramètre;
 La propriété lineCount en lecture seule permet de savoir le
nombre de lignes dont le texte est composé
 La propriété rows permet de définir le nombre de ligne affichée
par le composant
 JScrollPane permet d’ajouter une barre de défilement verticale et
horizontale
 Exemple
JTextArea textArea1 = new JTextArea ("mon texte");
JScrollPane scrollPane = new JScrollPane(textArea1);
scrollPane.setPreferredSize(new Dimension(200,70));
 Les onglets
 La classe javax.swing.JTabbedPane encapsule un ensemble
d'onglets. Chaque onglet est constitué d'un titre, d'un
composant et éventuellement d'une image.
 Pour utiliser ce composant, il faut :
 instancier un objet de type JTabbedPane
 créer le composant de chaque onglet
 ajouter chaque onglet à l'objet JTabbedPane en utilisant
la méthode addTab()
 Exemple
JPanel onglet1 = new JPanel();
JLabel titreOnglet1 = new JLabel("Onglet 1");
onglet1.add(titreOnglet1);
onglet1.setPreferredSize(new Dimension(300, 80));
onglets.addTab("onglet1", onglet1);
addTab(String, Component) permet d'ajouter un nouvel onglet
dont le titre et le composant sont fournis en paramètres;
insertTab(String, Icon, Component, String, index) permet
d'insérer un onglet dont la position est précisée dans le dernier
paramètre ;
remove(int) permet de supprimer l'onglet dont l'index est fourni
en paramètre ;
 Les menus
Création de Menu en suivant les étapes suivantes :
 Insérer les menus dans des objets de la classe Frame ;
 Créer une barre de menu et l'affecter à la fenêtre d'encadrement.
MenuBar mb = new MenuBar();
setMenuBar(mb);
 Créer ensuite créer les entrées de chaque menu et les rattacher à la barre.
Menu m = new Menu(" un menu ");
mb.add(m);
 Ajouter ensuite les éléments à chacun des menus.
m.add(new MenuItem(" 1er element "));
m.add(new MenuItem(" 2eme element "));
Menu m2 = new Menu(" sous menu ");
…
m.add(m2);
 MenuItem add(MenuItem) void add(String) :ajouter une option dans le menu
 void addSeparator() :ajouter un trait de séparation dans le menu