ppt - LAMSADE

Les composants Graphiques
Atomiques
Les
Labels (JLabel)
Zone de texte (JTextFiled)
Les boutons de commande (Jbutton,
JCheckBox, )
Les listes
Les menus
Les Labels (JLabel)
Servent essentiellement à afficher du
texte et des images (texte d’information)
 La classe utilisée est JLabel

– Constructeurs:
• new JLabel("Text")
• new JLabel(ImageIcon)
• new JLabel("Text", ImageIcon, AligHorizotal)
setForGround(Color)
 setFont(Font)
 New Font(font, style, taille)

Exemple JLabel
// création de la fenêtre récupération de son container et mise ajours de
//son gestionnaire d’emplacement
JFrame JPF=new JFrame("fenêtre sur les Jlabel");
Container JCP=JPF.getContentPane();
JCP.setLayout(new GridLayout(3,0,10,10));
//création des images à insérer
ImageIcon image1=new ImageIcon("c:\\email.gif");
ImageIcon image2=new ImageIcon("c:\\email.gif");
//création des JLabel selon les trois modèles
JLabel text=new JLabel("courier gras et de taille 15");
JLabel icon=new JLabel(image1,JLabel.LEFT);
JLabel texteETicon=new JLabel("je suis le texte ……",image2,JLabel.LEFT);
//changement des caractéristiques de la police du label1
text.setForeground(Color.BLUE);
text.setFont(new Font("courier",Font.BOLD,15));
//ajout des label au container de la fenêtre & affichage
JCP.add(text);
JCP.add(icon);
JCP.add(texteETicon);
JPF.pack();
JPF.show();
Les zones de texte (1)
Utilisés généralement pour saisir des
informations destinées au programme
 Les zones texte en swing sont assurées
par la hiérarchie suivante:

Zone texte (2):
JTextField & JPasswordText

Destinés pour saisir du texte sur une seule
ligne
 Constructeurs:
–
–
–
–
new
new
new
new
JTextField(String)
JTextField(String,int)
JPasswordText(String)
JPasswordText(String,int)
getText(): récupère le contenue actuel du
JTextField
 setFont(Font);
 setForGround(Color)

Pour JPasswordText utilisez la méthode char[] getPassword() et
non getText().
JTextArea

Utilisé pour afficher ou saisir du texte sur
plusieurs ligne.
 Constructeurs:
– new JTextArea(String)
– new JTextArea(int ligne, int colonne)
setFont(Font)
 setForground(Color)
 Par défaut le texte est changeable
 setEditable(false);

Exemple: zone Texte
JLabel label1= new JLabel("JTextField:");
JTextField text=new JTextField("texte par défaut");
JLabel label2= new JLabel("JPasswordField:");
JPasswordField psText=new JPasswordField();
JPanel panel1=new JPanel(new GridLayout(2,2));
panel1.setBorder(BorderFactory.createTitledBorder(
BorderFactory.createLineBorder(Color.BLACK,3),"les zones Texte"));
panel1.add(label1);panel1.add(text);
panel1.add(label2);panel1.add(psText);
JTextArea textArea = new JTextArea( "ceci est une JTextArea. " +……);
textArea.setEditable(false);
textArea.setFont(new Font("Serif", Font.ITALIC, 16));
textArea.setLineWrap(true);
textArea.setWrapStyleWord(true);
JPanel panel2=new JPanel(new GridLayout(1,1));
panel2.setBorder(BorderFactory.createTitledBorder(
BorderFactory.createLineBorder(Color.BLACK,3),"JTextArea"));
panel2.add(textArea);
JCP.add(panel1);JCP.add(panel2);
JPF.pack();
JPF.show();
Les boutons: les JButton
utilisés pour enregistrer ou réagir au
commande de l’utilisateur.
 Constructeur:

–
–
–
–
new
New
New
New
JButton();
Jbutton(String);
Jbutton(Icon);
Jbutton(String ,Icon);
Peut être activé ou désactivé
 Le JButton réagit graphiquement au clic
 Quand il est désactivé, l’action clic n’a aucun
effet
 Quelques méthodes:

– SetEnable(boolean) // change l’état d’activité du
bouton
– Set
Exemple: Jbutton
public static void main(String [] args)
{// création de la fenêtre
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame testButton=new JFrame ("exemple sur les Jbutton");
Container c=testButton.getContentPane();
c.setLayout(new FlowLayout());
//Création des trois boutons
JButton text=new JButton("je suis un boutton séléctionnée");
text.setDefaultCapable(true);
JButton textETicon=new JButton(
"texte + image",new ImageIcon("c:/orange.gif"));
JButton textD=new JButton("je suis un boutton désactivé");
// désactiver le bouton
textD.setEnabled(false);
// ajouter les boutons
c.add(text);c.add(textETicon);c.add(textD);
testButton.initialisation();
testButton.pack();testButton.show();
}}
Les Boutons: JCheckBox

Utilisés pour le choix des options ou des
réponses
 Les constructeurs:
– new JCheckBox(String,[boolean]);
– new JCheckBox(Icon,[boolean]);
– Les deux.

quelques méthodes:
– setSelected(boolean) //sélectionner l’option
– Boolean isSelected() // teste l’état du bouton
Exemple: JCheckBox
public static void main(String [] args)
{// création de la fenêtre
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame testCheck=new JFrame ("exemple sur les JCheckBox");
Container c=testCheck.getContentPane();
c.setLayout(new FlowLayout());
//Création des Jcheckbox dans un panel
JPanel listchoix=new JPanel(new GridLayout(0,1,10,10));
JCheckBox lun=new JCheckBox("Lunettes");
JCheckBox cas=new JCheckBox("Casquette");
JCheckBox chau=new JCheckBox("Chaussures");
listchoix.add(lun);listchoix.add(cas);listchoix.add(chau);
// création de l'image
JLabel labelimage=new JLabel(new ImageIcon("c:\\checkbox.gif"));
// ajout des checkbox et l'image dans la fenêtre
c.add(listchoix);c.add(labelimage);
// affichage
testCheck.pack();testCheck.show();
}
Bouton: JRadioButton

Contrairement au Jcheckbox, utilisé pour le
choix exclusive (homme-femme etc.)
 Nécessité de placer les choix dans un objet
contexte: ButtonGroup
 Constructeur:
– Les mêmes que JCheckbox

Les opérations:
– Les mêmes que pour JCheckBox

ButtonGroup:
 Constructeur: un seul, pas de paramètre
 Ajouter des JRadioButton: add(AbstractButton)
Exemple: JRadioButton
public static void main(String [] args)
{// création de la fenêtre
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame testCheck=new JFrame («
exemple sur les JRadioButton & ButtonGroup");
Container c=testCheck.getContentPane();
c.setLayout(new FlowLayout());
//Création des boutton de choix
JPanel listchoix=new JPanel(new GridLayout(0,1,10,10));
JRadioButton rose=new JRadioButton("petit couchon Rose");
JRadioButton bleu=new JRadioButton("petit couchon Bleu");
JRadioButton noir=new JRadioButton("petit couchon Noire");
listchoix.add(rose);listchoix.add(bleu);listchoix.add(noir);
//regrouper les bouttons dans une même contexte
ButtonGroup gb=new ButtonGroup();
gb.add(rose);gb.add(bleu);gb.add(noir);
// création de l'image
JLabel labelimage=new JLabel(new ImageIcon("c:\\pig.gif"));
// ajout des checkbox et l'image dans la fenêtre
c.add(listchoix);c.add(labelimage);
// affichage
testCheck.pack();testCheck.show(); }
Les listes: JList
Utilisés pour présenter à l’utilisateur un ensemble
d’éléments (peuvent être utilisées pour le choix
multiple)
 Les éléments peuvent être affichés sur plusieurs
lignes et colonnes
 Constructeur:

– New JList(Object[]) //liste immuable
– new JList(Vector) //liste immuable
– new JList(DefaultListModel) //liste changeable

Par défaut la liste est multi-modale (on peut
sélectionner plusieurs éléments) et verticale.
JListe (2)

Changer l’orientation de la liste:
– setLayoutOrientation(int);
– Trois constantes
HORIZONTAL_WRAP

VERTICAL_WRAP
VERTICAL
Changer le mode de sélection
– setSelectionMode(int)
– Trois constantes
SINGLE_SELECTION
SINGLE_INTERVAL_SELECTION MULTIPLE_INTERVAL_SELECTION
JList (3)

Quelques méthodes
– setModel(ListModel); //changer la liste modèle
– Object getSelectedValue();
– Object[] getSelectedValues();

DefaultListModel // constructeur vide
– addElement(Object); //ajouter un élément dans la liste
– int getCapacity(); // retourne nombre d’éléments
– …….

Les ascenseurs:
– Ajouter des ascenseur pour permettre de gérer la taille de la
liste.
– Class : JScrollPane
– Constructeur : JScrollPane(Component);
– Il peut être ajouté à une zone JTextArea
– Ajouter l’objet ascenseur à la place de la liste
Exemple: JList
//déclaration de l’objet fenêtre et récupération de son container
………..
//création d'un objet DefaultListModel
DefaultListModel lm=new DefaultListModel();
//création d'un objet Jliste avec comme modèle liste "lm"
JList list=new JList(lm);
// ajout des employés dans le modèle de la liste "lm"
lm.addElement(new Employé("Alan", "Sommerer","Directeur"));
lm.addElement(new Employé("Alison","Huml", "marketing"));
lm.addElement(new Employé("Kathy","Walrath", "comercial"));
lm.addElement(new Employé("Lisa","Friendly", "marketing"));
…..
JLabel text=new JLabel("Quel sont vos enployés préféré ?????");
//création de l'assenseur et on fixe sa taille
JScrollPane listScroller = new JScrollPane(list);
listScroller.setPreferredSize(new Dimension(250, 80));
text.setForeground(Color.red);
//ajout des deux composants au container de la fenêtre affichage
JCP.add(text);
JCP.add(listScroller);
JPF.pack();JPF.show();
List: comboBox

Une liste ou un élément est sélectionné
à la fois
exemple
Les menus
Une manière d’organiser les boutons de
commande et les boutons d’options qui
ont un intérêt pour l’application.
 exemple en image:
Bar de menu: JMenuBar

Un élément de menu:JMenuItem
Un menu: JMenu
Vue global de l’API menu
JMenuBar
Chaque fenêtre peut comporter un et
un seul JMenuBar
 Utilisation de la méthode de JFrame:

– setJMenuBar(JMenuBar)
Constructeur : new JMenuBar();
 Méthode d’ajout de menus

– Add(JMenue)
JMenu

Constructeurs:
– JMenu(String);
– JMenu(String,boolean)

Ajouter des des éléments:
– Add(JMenuItem)
– fichier.addSeparator();// ajoute une ligne de
séparation
– Vous pouvez également ajouter des objets
de type JMenu pour les sous-menus
JMenuItem
Ressemble à JButton (texte et icon)
 Constructeur: JMenuItem(String, [Icon])
 Les sous classes possibles

– JRadioButtonMenuItem (regrouper dans
des ButtonGroup)
– JCheckBox.
– Le même fonctionnement.
Exemple: testons le tout
//création de la fenêtre
………
//création d’un object JMenuBar
JMenuBar menuBar = new JMenuBar();
//remplacement de JMenuBar de la fenêtre par l’objet crée
fenêtre.setJMenuBar(menuBar);
//création du Menu_1 …….
JMenu jmenu1= new JMenu("JMenu_1");
JMenu jmenu2=new JMenu("JMenu_2");
jmenu1.add(new JMenuItem("JMenuItem_1 sans Icon"));
jmenu1.add(new JMenuItem("JMenuItem_2 avec Icon",new ImageIcon("c:\\...gif")));
jmenu1.addSeparator();
jmenu1.add(new JRadioButtonMenuItem("JRadioButtonMenuItem",true));
jmenu1.addSeparator();
jmenu1.add(new JCheckBoxMenuItem("JCheckBoxMenuItem",true));
jmenu1.addSeparator();
JMenu sm=new JMenu("Sous Menu_1");
jmenu1.add(sm);
sm.add(new JMenuItem("JMenuItem_1 de Sous Menu_1"));
sm.add(new JMenuItem("JMenuItem_2 de Sous Menu_1"));
//ajout des deux Menu à l’objet "menuBar"
menuBar.add(jmenu1);menuBar.add(jmenu2);
fenêtre.pack();fenêtre.show();
Les menus
 Les élément de tous types et les sous
menu.

Résumons : on sait faire!!!!
Création de fenêtres
 Ajout des composants graphiques dans
la fenêtre
 Organisation de la disposition des
objets graphiques
 On connaît les objets graphiques pour
traiter le texte, les images, les choix, les
listes et les boutons de commande

Comment associer les actions de l’utilisateur sur l’interface
graphique pour manipuler les données de l’application??????

programmation des interfaces
Problématique
Vecteur
d’employés
jean
Gilles
Philipe
Un interpréteur d’évènement graphique qui récupère
les données, crée un objet Employé et l’ajoute à la liste
Huber
Programmation évènementielle
• Concevoir un programme comme une entité normalement
inactive qui réagit de façon particulière à chaque
événement (prévu) qui intervient.
• Programmer une interface consiste à associer un traitement
à chaque objet Graphique
stimuli
Objet
Graphique
evt1
evt2
Tant que NON(Evt) faire
Rien
Selon que
Evt=evt1: action1
Evt=evt2: action2
application
Qu’est ce qu’un événement???
Les événements sont des objets java
 Un évènement graphique peut être

– Un clic
– Un double clic
– Bouger la souris
– Taper du texte
– Fermer une fenêtre …….

Chaque objet graphique est capable de
réagir à un certain type d’évènement
Les événements en java
java.lang.Object
java.util.EventObject
vos événements généraux,
(pas forcément graphiques)
Java.awt.AWTEvent
vos événements graphiques
java.awt.event.ActionEvent
Exemple : tous les boutons déclenchent des « ActionEvent »
méthodes: l’objet évènement





Tous les événement sont des sous class de
EventObject.
Chaque événement porte un certain nombre
d’information sur son contexte
La classe EventObject maintent un seul
méthode hérité par tous les evènement:
public Object getSource()
Elle retourne une référence vers l’objet
graphique responsable de l’événement.
exemple MouseEvent propose deux
méthode getX() et getY() qui retourne les
coordonnées du point où l’événement est
arrivé
Gestion des événements en java
« modèle par délégation »
Événement
Source
Listener
Un événement est propagé d'une Source vers un objet
Listener (ou écouteur) en invoquant une méthode du listener
et en passant une sous-classe de EventObject qui définit le
type d’événement qui a été engendré.
Gestion des événements
Chaque fois que l’utilisateur click sur un bouton de
commande, tape du texte ou bouge la souris…., un
événement survient
 L’objet graphique concerné crée un objet événement
de type d’événement correspondant .
 programmer une interface graphique consiste alors à
associer un comportement à chaque événement
appropriés.
 JAVA: pour chaque type d’événement une interface
Listener est associer.
 Tous ce que vous avez à faire: c’est d’implémenter
les interfaces correspondant aux événements
souhaité.

Les listeners






Un objet listener est un objet qui implémente
(remplit le contrat d’) une interface spécifique.
Cette interface (ce contrat) prévoit une ou
plusieurs méthodes qui peuvent être
invoquées par une source d’événements.
Java maintient une liste d’interfaces pour
chaque type d’évènement
Chaque Listener reçoit une réplique identique
de l’événement original.
Chaque Listener est composé d’un ou
plusieurs méthode
Chaque méthode prend en paramètre un
objet événement approprié.
Tableau de l’API Event et Listener
Listener Interface
Méthodes et évènement
ActionListener
actionPerformed(ActionEvent)
ComponentListener
componentHidden(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)
………
MouseListener
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
……….
WindowListener
……….
windowActivated(WindowEvent)
windowClosed(WindowEvent)
windowClosing(WindowEvent)
windowDeactivated(WindowEvent)
………
…………….
Exemple ActionListener

Exemple d’une interface prédéfini par java pour
traiter les évènements de type ActionEvent.
package java.awt.event;
import java.util.EventListener;
public interface ActionListener extends EventListener
{
public void actionPerformed(ActionEvent e);
}
La source
= Tous les composants graphiques
qu’on a vu.
 L'objet Source émet des événements.
 La source enregistre ses listeners par
des méthodes set<EventType>Listener
ou add<EventType>Listener.
 Toutes les sources d’événements
supportent un modèle multicast pour
l’émission : plusieurs listeners peuvent
être ajoutés pour une seule source.
 L'API n’a aucun à priori sur l'ordre dans
lequel les événements sont délivrés.

« Méthode connue sur composant inconnu »
Public Class Chronometre
implements ActionListener
Public Class Explosif
implements ActionListener
Listeners
chronometre
actionPerformed(ev)
ActionEvent
explosif
actionPerformed(ev)
ActionEvent
On
Le bouton ne « voit » que des ActionListener
Résumons

Les évènement sont traités par des classes qui
implémentent des interfaces XXXListener
 Java prévoit une interface XXXListener pour
chaque type d’événement
 L’implémentation des interfaces XXXListener
représente le comportement de l’application en
réponse à l’événement en question.
 Les objets des classes implémentant un
Listener doivent être rattachés à l’objet
graphique en question.
Les étapes

Une fois vos composants graphiques créés
 il suffit de créer un ou plusieurs objets
Listeners (implémentant le protocole ==
déclarant une méthode de réaction à un
événement)
 de les déclarer comme listeners de vos
composants graphiques (addActionListener..
addMouseListener)

et c’est tout…….
:^)
Exemple très simple!!!!!!!!!!!

Écrivez une interface graphique contenant un
bouton de commande
 Le bouton de commande contient le chiffre 0;
 Programmer le bouton de tel façon que le
chiffre dans le bouton s’incrémente à chaque
click
 Indication: utilisez l’interface ActionListener
Solution:


1.
Quel est l’événement qu’on veux
programmer?? Click (souris)
Le Listener ou écouteur de l’événement
click est l’interface ActionListener.
Implémenter cette interface == implémenter la
méthode actionPerformed:
public class EcouteurIncré implements ActionListener
public void actionPerformed(ActionEvent e){ ……}
2.
Rattacher une instance de cette class à l’objet
bouton :
MonBouton.addActionListener(EcouteurIncré);
Plus précisément
import java.awt.event.*;
import javax.swing.*;
public class EcouteurIncrémentation implements ActionListener{
int i=0;
public EcouteurIncrémentation() {}
public void actionPerformed(ActionEvent e){
System.out.println("************"+e.toString());
((JButton)e.getSource()).setText("click n° "+i);i++;
}}
public class Testincrémentation {
public Testincrémentation() {
}
public static void main(String[] args)
{JFrame.setDefaultLookAndFeelDecorated(true);
JFrame fenêtre =new JFrame("fenêtre programmé");
fenêtre.setSize(300,100);
JPanel p=new JPanel();
JButton incr=new JButton("click ici");
incr.setSize(20,20);
incr.addActionListener(new EcouteurIncrémentation());
p.add(incr);
fenêtre.getContentPane().add(BorderLayout.SOUTH,p);
fenêtre.show(); }}