Swing Partie 2

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 41

POO – JAVA

Interface graphique avec Swing

Youness KHAMLICHI IDRISSI 1


JAVA

Fenêtres de dialogues

Youness KHAMLICHI IDRISSI 2


Message de dialogue
public static void main(String[] args) {

JOptionPane jop1 = new JOptionPane();


JOptionPane jop2 = new JOptionPane();

String nom = jop1.showInputDialog(null, "Veuillez entrez votre


nom : ", "GSEII Identité", JOptionPane.QUESTION_MESSAGE);
jop2.showMessageDialog(null, "Votre nom est : "+nom, "GSEII :
Name of Student", JOptionPane.INFORMATION_MESSAGE);

3
Message de dialogue
public static void main(String[] args) {
String[] sf = {"célibataire", "marié(e)", "divorcé(e)", "Veuf(ve)"};
JOptionPane jop1 = new JOptionPane();
JOptionPane jop2 = new JOptionPane();

String nom = (String) jop1.showInputDialog(null,


"Veuillez indiquer votre situation familiale : ",
"GSEII Identité",
JOptionPane.QUESTION_MESSAGE,
null,
sf,
sf[0]);
jop2.showMessageDialog(null, "Votre situation familiale est : " +
nom, "GSEII : Situation of Student",
JOptionPane.INFORMATION_MESSAGE);

4
Option de dialogue
public static void main(String[] args) {
String[] sf = {"célibataire", "marié(e)", "divorcé(e)", "Veuf(ve)"};
JOptionPane jop1 = new JOptionPane();
JOptionPane jop2 = new JOptionPane();
int choix = jop1.showOptionDialog(null,
"Veuillez indiquer votre situation familiale : ",
"GSEII Identité",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
sf,
sf[0]);
jop2.showMessageDialog(null, "Votre situation familiale est : " +
sf[choix], "GSEII : Situation of Student",
JOptionPane.INFORMATION_MESSAGE);

5
Boites de dialogue
personnalisées
import javax.swing.JDialog;
import javax.swing.JFrame;

public class GDialog extends JDialog{

public GDialog(JFrame owner, String title, boolean modal) {


//On appelle le constructeur de JDialog correspondant
super(owner, title, modal);
//On spécifie la taille
this.setSize(200, 80);
//La position
this.setLocationRelativeTo(null);
//La boîte ne devra pas être redimentionnable
this.setResizable(false);
//Enfin on l'affiche
this.setVisible(true);
}
}

6
Boites de dialogue
personnalisées
public static void main(String[] args) {
GDialog gd = new GDialog(null, "Titre Dynamique", true);

7
JAVA

Gestion des évènements en SWING

Youness KHAMLICHI IDRISSI 8


Le modèle événementiel

 Les événements sont un moyen de communication


alternatif entre deux objets.
 Les communications par événements sont asynchrones.
 Un objet lance un événement et un autre objet attrape cet
événement.
 Exemple d’événement :
 Click de sourie, changement d’une base de données …

9
Le modèle événementiel

 Dans le modèle événement de Java, le tout est objet :


 Le lanceur d’événement est un objet
 Le receveur d’événement est un objet
 L’événement est un objet.

10
Gestion des événements

 Que se passe t il ?
quand on appuie sur un bouton,
quand on ferme une fenêtre,
quand on bouge la souris …
 Un événement contenant le lieu, la nature et l’objet
« actionné » (ActionEvent) est créé par le système graphique.
Cet événement est différent selon qu’il s’agit d’un clic sur un
bouton, le déplacement de la souris, etc…
 Le « dispatcher » envoie cet événement aux objets qui se sont
déclarés intéressés par cet événement

Youness KHAMLICHI IDRISSI 11


Gestion des événements

 Qui est intéressé ?


Des objets de type écouteur
C’est le bouton qui provoque les événements qui autorise
les écoutes.
Les objets écouteurs définissent les actions qui doivent
avoir lieu
Cette action est définie par un <typeevenement>Listener,
fonction qui précise l’entête des fonctions gérant l’action.

Youness KHAMLICHI IDRISSI 12


Ecouter un bouton

 Il faut créer l’interface graphique :


une fenêtre de base
Un bouton
 Il faut créer la classe qui écoute : elle implémente l’interface
actionlistener qui permet de gérer les clics sur un bouton, les
sélections de menu
On définit dans cette classe la méthode
actionPerformed(…) qui explicite ce qui doit être fait
quand on clique sur un bouton : ici on affiche sur la
fenêtre console le texte « Action sur le bouton »

Youness KHAMLICHI IDRISSI 13


Ecouter un bouton

 On crée un objet de cette classe : objetecoutant


En pratique, le nom de la variable est souvent inutile : on
crée des objets anonymes, sans nom
 On enregistre cet objet auprès du bouton par la méthode
addActionListener, car c’est quand même le bouton qui
autorise ou non l’écoute

Youness KHAMLICHI IDRISSI 14


Exemple d’événement
 La classe JButton est capable
de lancer l’événement java.awt.Event.ActionEvent
 Cet événement est lancé lorsque l’on clique sur un
bouton.
 Les classes capables de recevoir cet événement doivent
implanter l’interface java.awt.event.ActionListener
 Pour qu’un receveur (listener) se connecte à un lanceur,
il doit appeler la méthode addActionListener()
du lanceur.
 Lorsque le lanceur lance un événement, il appelle les
méthodes actionPerformed(ActionEvent e) de l ’interface
ActionListener
15
Exemple d’événement

 La classe receveur
public class MonListener implements java.awt.event.ActionListener {
public void actionPerformed(ActionEvent e) {
System.out.println(“evenement recu !”);
}
}

 Quelque part dans le programme, le lien entre le receveur et le
lanceur
java.swing.JButton button = new java.swing.JButton(“click”);

button.addActionListener(new MonListener());

16
Ecouter un bouton et réagir
import javax.swing.*; import java.awt.*; import java.awt.event.*;
class Ecouteur1 extends JFrame {
private JButton button;
public Ecouteur1 () { super("exemple ecouteur 1");
button = new JButton("Appuyer pour afficher un texte");
Monecouteur objetecoutant = new Monecouteur();
button.addActionListener(objetecoutant);
add(button, BorderLayout.CENTER);
pack(); setVisible(true);
} /* Classe interne à la classe ecouteur1 souvent utilisée pour les listener
On peut aussi définir une classe externe. */
class Monecouteur implements ActionListener {
public void actionPerformed(ActionEvent event) {
System.out.println("Action sur le bouton"); }
}}
public class Test8{
public static void main(String[] args) { new Ecouteur1();}
}

Youness KHAMLICHI IDRISSI 17


Ecouter 2 boutons (1)
 Une application qui affiche un compteur mis à jour par 2 boutons
 Il faut créer l’interface graphique :
 une fenêtre de base
 un bouton « plus », un bouton « moins »
 Un label qui affiche le compteur
 Une variable entière contenant le compteur
 Pour gérer les boutons, plusieurs solutions
 Version objet avec 2 écouteurs : une classe écouteur spécifique pour
chaque bouton. Il y a donc 2 classes, une pour le moins, une pour le
plus. Aucun test n’est à faire dans l'écouteur, puisqu’il sait quel bouton
est utilisé
 Version 1 écouteur : une seule classe écouteur, qui teste si le composant
d’où provient l’événement est le bouton plus ou le bouton moins
 Version 1 écouteur this : la classe écouteur est la classe qui définit
l’application elle-même

Youness KHAMLICHI IDRISSI 18


Ecouter 2 boutons (1)
import javax.swing.*; import java.awt.*; import java.awt.event.*;
// Deux boutons : un qui décrémente, un qui incrémente
class Ecouteur2 extends JFrame {
private int count = 0; JLabel label; JButton buttonPlus, buttonMoins;
private void creationinterface() {
buttonPlus = new JButton("plus"); buttonMoins = new JButton("moins");
label = new JLabel("0", JLabel.CENTER);
JPanel buttons = new JPanel(new GridLayout(0, 1));
buttons.add(buttonPlus); buttons.add(buttonMoins);
JPanel pane = new JPanel(new BorderLayout());
pane.add(buttons, BorderLayout.WEST);
pane.add(label, BorderLayout.CENTER);
getContentPane().add(pane, BorderLayout.CENTER);
pack(); setVisible(true); }
public Ecouteur2() { super("exemple"); creationinterface();
buttonPlus.addActionListener(new MyActionListener1());
buttonMoins.addActionListener(new MyActionListener2());
addWindowListener(new MyWindowListener ());
}
Youness KHAMLICHI IDRISSI 19
Ecouter 2 boutons : 2 écouteurs
private class MyActionListener1 implements ActionListener {
public void actionPerformed(ActionEvent event) {
count++; label.setText(Integer.toString(count));
} }
private class MyActionListener2 implements ActionListener {
public void actionPerformed(ActionEvent event) {
count--; label.setText(Integer.toString(count));
}
} // Remarque ; les classes internes ont accès aux champs de l’interface
private class MyWindowListener extends WindowAdapter {
public void windowClosing(WindowEvent event) { System.exit(0); }
}}
public class Ex46 {
public static void main(String[] args) { new Ecouteur2(); }
}

Youness KHAMLICHI IDRISSI 20


Ecouter 2 boutons : 1 seul écouteur

private class MyActionListener implements ActionListener {


public void actionPerformed(ActionEvent event) {
if(event.getSource() == buttonPlus) count++; else count--;
label.setText(Integer.toString(count));
}
}
private class MyWindowListener extends WindowAdapter {
public void windowClosing(WindowEvent event) { System.exit(0); }
}
}
public class Ex47 {
public static void main(String[] args) { new Ecouteur2(); }
}

Youness KHAMLICHI IDRISSI 21


Ecouter 2 boutons : 1 ecouteur=this
import javax.swing.*; import java.awt.*; import java.awt.event.*;
class Ecouteur2 extends WindowAdapter implements ActionListener {JFrame frame;
private int count = 0; JLabel label; JButton buttonPlus, buttonMoins;
private void creationinterface() { frame=new JFrame("Exemple");
buttonPlus = new JButton("plus"); buttonMoins = new JButton("moins");
label = new JLabel("0", JLabel.CENTER);
JPanel buttons = new JPanel(new GridLayout(0, 1));
buttons.add(buttonPlus); buttons.add(buttonMoins);
JPanel pane = new JPanel(new BorderLayout());
pane.add(buttons, BorderLayout.WEST);
pane.add(label, BorderLayout.CENTER);
frame.getContentPane().add(pane, BorderLayout.CENTER);
frame.pack(); frame.setVisible(true);
}
public Ecouteur2() { creationinterface();
buttonPlus.addActionListener(this);
buttonMoins.addActionListener(this);
frame.addWindowListener(this);
}
public void actionPerformed(ActionEvent event) {
if(event.getSource() == buttonPlus) count++;
if(event.getSource() == buttonMoins) count--;
label.setText(Integer.toString(count));
}
public void windowClosing(WindowEvent event) { System.exit(0); }
}
public class Ex48 {public static void main(String[] args) { new Ecouteur2(); } }

Youness KHAMLICHI IDRISSI 22


Le lanceur d’événement
 Un objet qui lance des événements doit proposer des
méthodes pour que des receveurs puissent d’enregistrer.
 Ces méthodes sont toujours sous la forme
addXXXListener()
Où XXX est le type d’événement lancé.
 Lorsqu’il jette un événement, le lanceur le jette vers tous
les objets qui se sont enregistrés.
 Les méthodes
 removeXXXListener()
 Permettent de ne plus enregistrer des objets.

23
Les actions sur une fenêtre
 Il faut créer l’interface graphique : c’est le même code
 Il faut créer une classe (ici Monecouteurfenetre) qui implémente l’interface
WindowListener qui permet de gérer les fenêtres
 Il faut définir 7 méthodes, même si elles sont vides
void windowOpened(WindowEvent e) : ouverture de la fenêtre
void windowClosed(WindowEvent e) : après la fermeture de la fenêtre
void windowClosing(WindowEvent e) : au moment de la fermeture de la
fenetre
void windowIconified(WindowEvent e) : iconifier la fenêtre
void windowDeiconified(WindowEvent e) : deiconifier de la fenetre
void windowActivated(WindowEvent e) : focus dans la fenêtre; Utiliser de
préférence windowGainedFocus de WindowFocusListener
void windowDeactivated(WindowEvent e) : perte du focus de la fenetre.
Utiliser de préférence windowLostFocus de WindowFocusListener
 On crée un objet anonyme, sans nom car c’est inutile
 On enregistre cet objet auprès de la fenêtre par la méthode addWindowListener

Youness KHAMLICHI IDRISSI 24


Les adaptateurs
 Si on utilise une interface listener : toutes les méthodes doivent être écrites,
même vides
 exemple : windowsListener : 7 méthodes à redéfinir
windowActivated, windowClosed, windowClosing,
WindowDeactivated, windowDeiconified, windowIconified,
windowOpened
 Gérer les événements par adaptateur
 Un adaptateur : une classe contient déjà une version vide
 on ne surcharge que les fonctionnalités dont on a besoin
 Attention : la classe ecouteur HERITE de la classe Adapter au lieu de
IMPLEMENTE une interface
FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter

Youness KHAMLICHI IDRISSI 25


Les adaptateurs

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);}
}

26
Les actions sur une fenêtre
(1/3)
import javax.swing.JFrame;
import javax.swing.JButton;
import java.awt.BorderLayout;
import java.awt.event.WindowAdapter;
public class ecouteur2 extends WindowAdapter{
private JButton bouton, JFrame frame;
public ecouteur2() {
frame = new JFrame("Exemple d'écouteur");
bouton = new JButton("Appuyez pour afficher un texte");
MonEouteur objetecoutant = new MonEouteur();
bouton.addActionListener(objetecoutant);
frame.add(bouton, BorderLayout.CENTER);
MonEcouteurFenetre listener = new MonEcouteurFenetre();
frame.addWindowListener(listener);
frame.pack();
frame.setVisible(true);
}
public static void main(String[] argv){new ecouteur2(); }}

Youness KHAMLICHI IDRISSI 27


Les actions sur une fenêtre
(2/3)
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MonEouteur implements ActionListener{

@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Action sur le bouton");

Youness KHAMLICHI IDRISSI 28


Les actions sur une fenêtre
(3/3)
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
public class MonEcouteurFenetre implements WindowListener{
public void windowOpened(WindowEvent e) {
System.out.println("windowOpened");}
public void windowClosing(WindowEvent e) {
System.out.println("windowClosing");}
public void windowClosed(WindowEvent e) {
System.out.println("windowClosed");}
public void windowIconified(WindowEvent e) {
System.out.println("windowIconified");}
public void windowDeiconified(WindowEvent e) {
System.out.println("windowDeiconified");}
public void windowActivated(WindowEvent e) {
System.out.println("windowActivated");}
public void windowDeactivated(WindowEvent e) {
System.out.println("windowDeactivated");}
}

Youness KHAMLICHI IDRISSI 29


Résumé
 la gestion des événements est faite par délégation par un listener ou un adapter
 l'événement n'est pas géré par le composant source de l’événement mais par un objet qui
s'est déclaré intéressé (écouteur) par ce type d'événement au moyen de add<type>Listener()
ou set<type>Listener() auprès de l'objet source
 cet objet écouteur doit implanter la ou les méthodes précisées par le type de listener. Ces
méthodes décrivent ce qui doit être fait avec l'événement. Un listener est une interface au
sens Java du terme. Il faut définir toutes les méthodes de l’interface, même si elles sont
vides.
 Un adapter est une classe contenant des versions vides des méthodes. On redéfinit
uniquement celles qui sont nécessaires. Une classe ecouteur doit alors héritée de l’adapter.
 s'il existe plusieurs objets écouteurs, tous reçoivent une copie de l'événement dans un ordre
non défini.
 Si aucun listener n'est défini, l'événement est ignoré
 un écouteur peut écouter plusieurs sources différentes
 Un objet peut écouter plusieurs boutons
 Un objet peut écouter les événements issu de ses propres composants
 En pratique
 Définir et cééer l’interface graphique et ses boutons.
 Définir les écouteurs et les actions : ecrire les classes (Monecouteur) et méthodes
(ActionPerformed)
 Créer les ecouteurs des différents composants graphiques (new Monecouteur())
 Enregistrer les ecouteurs aupres des boutons à écouter (addActionListener(…))

Youness KHAMLICHI IDRISSI 30


Quelques Méthodes

 Les évènements sont typés, organisé en classes


Mouse  MouseEvent , clicbouton  ActionEvent

 Méthodes utiles
String getActionCommand() : retourne la chaîne associée à
l'évènement
int getModifiers() : entier contenant les touches enfoncées par
l'utilisateur (SHIFT, CTR)
Object getSource() : composant émettant l'événement
int getID() : retourne le type de l’événement
long getWhen() : retourne le temps écoulé depuis l’apparition de
l’évènement

Youness KHAMLICHI IDRISSI 31


Quel écouteur définir pour quelle action ?
Souris
 Interface ActionListener
Utilisée par les clics bouton, choix de menu, …
Méthodes à définir
void actionPerformed(ActionEvent e) : que faire lors de
l'apparition d’un des évènements
 Interface MouseListener ou classe MouseAdapter
Utilisée pour les actions souris entrant et sortant dans la
fenêtre, les clics dans la fenêtre
Méthodes à définir
void mouseClicked(MouseEvent e) : clic dans la fenêtre
void mouseEntered(MouseEvent e) : souris entrant dans la fenêtre
void mouseExited(MouseEvent e) : souris sortant de la fenêtre
void mousePressed(MouseEvent e) : touche souris appuyée dans
la fenêtre

Youness KHAMLICHI IDRISSI 32


Quel écouteur définir pour quelle action ?
Souris
Méthodes utiles
boolean isLeftMouseButton(MouseEvent e) : vrai si e
concerne le bouton gauche de la souris
boolean isMiddleMouseButton(MouseEvent e) : vrai si e
concerne le bouton milieu de la souris
boolean isRightMouseButton(MouseEvent e) : vrai si e
concerne le bouton droit de la souris
 Interface MouseMotionListener ou classe
MouseMotionAdapter
Utilisée pour les déplacement souris dans la fenêtre
Méthodes à définir
void mouseDragged(MouseEvent e) : clic dans la fenêtre
void mouseMovedMouseEvent e) : déplacement souris
dans la fenêtre

Youness KHAMLICHI IDRISSI 33


Exemple pour la souris
import javax.swing.*;import java.awt.event.*;import java.awt.*;

class Appli extends JFrame {


JLabel zone1;
public Appli() {
zone1 = new JLabel("Test de mouse",Jlabel.CENTER);
zone1.addMouseMotionListener(new Ecouteur());
getContentPane().add(zone1); setSize(200,200); setVisible(true);
}
private class Ecouteur implements MouseMotionListener {
private void affiche(MouseEvent e) {
System.out.println("x= "+e.getX()+", y="+e.getY());
` }
public void mouseMoved(MouseEvent e) { System.out.print("Mouvement"); affiche(e); }
public void mouseDragged(MouseEvent e) { System.out.print("Glisser"); affiche(e); }
}
}
public class Ex49 {
public static void main(String[] args) { new Appli(); }
}

Youness KHAMLICHI IDRISSI 34


Quel écouteur définir pour quelle action ?
Clavier
 Interface KeyListener ou classe KeyAdapter
Utilisée pour les actions clavier sur un composant
Le Composant doit pouvoir obtenir le focus avec
setFocusable(true)
Méthodes à définir
void keyTyped(KeyEvent e) : touche unicode (ascii) tapée
void keyPressed(KeyEvent e) : touche quelconque appuyée
dans le composant
void keyRealised(KeyEvent e) : touche quelconque relâchée
dans le composant
Principales méthodes de la classe KeyEvent
boolean isActionKey()
int getKeyChar(), int getKeyCode()

Youness KHAMLICHI IDRISSI 35


Quel écouteur définir pour quelle action ?
Clavier
 Interface ChangeListener
Utilisée les Sliders, les ColorChooser, les Spinners
Méthodes à définir
void stateChanged(ChangeEvent e) : changement dans le
composant
 Interface ItemListener
Utilisée les checkBoxes, les ComboBoxes
Méthodes à définir
void itemStateChanged(ItemEvent e) : changement dans le
composant
Principales méthodes de la classe ItemEvent
ItemSelectable getItemSelectable() : similaire à getSource()
Object getItem(), int getStateChange()

Youness KHAMLICHI IDRISSI 36


Quel écouteur définir pour quelle action ?
Clavier
 Interface FocusListener
Cette interface doit être implantée par les receveurs d’événement Focus
• public void focusGained(FocusEvent e)
public void FocusLost(FocusEvent e)
...
Sont des méthodes de cette interface.
• FocusEvent est l’objet représentant un événement de type
focus.
• Ces événements sont jeté par les Component, Button, ...

Youness KHAMLICHI IDRISSI 37


Quel écouteur définir pour quelle action ?
Clavier
 Interface AdjustmentListener
Cette interface doit être implantée par les receveurs d’événement
Adjustement
• public void adjustmentValueChanged(AdjustmentEvent e)
est la seule méthode de cette interface.
• AdjustmentEvent est l’objet représentant un événement de
type adjustment.
• Ces événements sont jeté par les Scrollbar ...

Youness KHAMLICHI IDRISSI 38


Exemple :Un chat local
 Taper du texte dans une fenêtre,
 Recevoir dans une autre, avec ascenseur

Youness KHAMLICHI IDRISSI 39


Exemple :Un chat local
import javax.swing.*; import java.awt.*; import java.awt.event.*;
public class Ex51 {
private JTextArea texte, copie;

public Ex51() {
// Fenetre principale qui envoie
JFrame frame = new JFrame("Chat");
// Gestion de la sortie de fenetre
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Création du panel de la fenetre principale
JPanel panelprincipal = new JPanel(new BorderLayout());
texte = new JTextArea();
// Partie texte de la Fenetre d’emission
JScrollPane paneltexte = new JScrollPane (texte);
// Bouton de la Fenetre d’emission
JButton button = new JButton("Envoyer");
panelprincipal.add(paneltexte, BorderLayout.CENTER);
panelprincipal.add(button, BorderLayout.SOUTH);
// Gestion de l'appui sur le bouton "Envoyer"
button.addActionListener(new MyActionListener());
frame.getContentPane().add(panelprincipal);

Youness KHAMLICHI IDRISSI 40


Exemple :Un chat local
// Creation de la deuxième fenetre pour la reception
JFrame fenetrecopie = new JFrame("Fenetre de reception");
// Création d'une zone de texte pour le message recu avec edition impossible
copie = new JTextArea(); copie.setEditable(false);
// Creation du panel de la fenetre de reception
JScrollPane panelcopie = new JScrollPane (copie);
fenetrecopie.getContentPane().add(panelcopie);
frame.setSize(200, 200); frame.setLocation(0, 0);
frame.setVisible(true);
fenetrecopie.setSize(200, 200); fenetrecopie.setLocation(400, 0);
fenetrecopie. setVisible(true);
}
private class MyActionListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
copie.append(texte.getText() + "\n");
// Lecture dans la fenetre d'emission (texte)
texte.setText(""); // et ecriture dans la fenetre de reception
} }
public static void main(String[] args) { new Ex51();}
}

Youness KHAMLICHI IDRISSI 41

Vous aimerez peut-être aussi