Next: 26 Les widgets
Up: Java: Programmation graphique
Previous: 24 Découvrir la programmation
Subsections
Un évènement est une message qu'un objet envoie à un autre objet lui
signalant la survenue de quelque chose de ``remarquable''. Il y a
donc un émetteur et un récepteur. Dans une application graphique, il y
a généralement une quantité importante d'objets et d'évènements
possibles. Tous les objets ne sont forcément intéressés par
l'ensemble des évènements. Par exemple, un bouton graphique ne
s'intéresse qu'aux seules évènements souris; les évènements clavier ne
l'intéressent pas. Aussi, pour être récepteur d'un évènement, un objet
devra signaler son intérêt pour cet évènement. Un même évènement peut
intéresser plusieurs objets et inversement un même objet peut
s'intéresser à plusieurs évènements.
Le modèle évènementiel de Java est basé sur les objets évènements,
les objets récepteurs et sources d'évènements.
La classe de base pour les évènements est la classe
java.util.EventObject
public class EventObject implements java.io.Serializable {
protected transient Object source;
public EventObject(Object source);
public Object getSource();
public String toString();
}
|
Le champ source code l'objet source de l'évènement.
Un évènement est alors une instance de cette classe ou d'une de ses sous classes.
Par exemple, l'ensemble des évènements graphiques sont des objets
des classes dérivées de java.util.EventObject.
class TestEvent extends java.util.EventObject {
public TestEvent(Object o) { super(o); }
}
|
Un récepteur est un objet à qui le système signale la survenue d'un évènement
et ce chaque fois qu'il se produit. L'émetteur de l'évènement doit savoir quelle
méthode il faut invoquer lorsqu'un évènement particulier survient.
Les récepteurs sont implantés à l'aide d'interfaces et l'interface de base de tous
les récepteurs est java.util.EventListener. Le nombre de méthodes définies
dans un récepteur est variable.
interface TestListener extends java.util.EventListener {
void TestEvènement1(TestEvent e)
void TestEvènement2(TestEvent e)
}
|
La signature des méthodes de ces interfaces est toujours de la forme void nom(TypeEvénement e).
Les émetteurs sont les objets qui déclenchent les évènements.
Ce sont des objets d'une classe qui doit implanter les méthodes pour permettre
à d'autres objets se s'abonner pour recevoir un évènement et éventuellement se désabonner.
public void addTestListener(TestListener l);
public void removeTestListener(TestListener l);
|
class TestEmetteur {
private TestListener AlEcoute = new TestListener[3];
int sommet = 0;
public synchronized void addTestListener(TestListener l) {
if (sommet < AlEcoute.length) AlEcoute[sommet++] = l;
}
public synchronized void removeTestListener(TestListener l) {
for (int i = 0; i <= sommet && AlEcoute[i] != l; i++);
if (i <= sommet)
for (; i < sommet; AlEcoute[i] = AlEcoute[i+1], i++);
sommet--;
}
public void notifyTestEvènement1() {
TestEvent e = new TestEvent(this);
// clone
for (int i = 0; i < AlEcoute.length; i++) {
TestListener l = AlEcoute[i];
l.TestEvènement(e);
}
}
}
|
La gestion des évènements graphiques suit le schémas général que nous venons d'exposer:
- Les évènements sont engendrés par des émetteurs
- Les récepteurs s'inscrivent auprès d'un ou plusieurs émetteurs pour signaler
leur intérêt pour les évènements.
- L'action à réaliser lorsque le ou les évènements attendus surviennent.
Les objets qui veulent gérer les évènements graphiques sont des instances
d'une classe qui implante l'interface ActionListener. On devra donc
trouver dans tout programme qui veut gérer les évènements les trois choses suivantes:
- une classe qui implante une interface ActionListener
public class X implements ActionListener { ... }
|
- une composant qui s'inscrit auprès d'un ou plusieurs émetteurs
un_composant.addActionListener(objet_de_la_class_X);
|
- l'implantation des méthodes de l'interface ActionListener i.e. l'action a réaliser
public void actionPerformed(ActionEvent e) {
...
}
|
Voici un exemple d'une application graphique qui réagit lorsqu'on appuie sur le bouton.
public class Click extends java.applet.Applet
implements java.awt.event.ActionListener {
java.awt.Button bouton;
boolean b = true;
public void init() {
bouton = new java.awt.Button("Cliquez ici");
add("Center", bouton);
bouton.addActionListener(this);
}
public void actionPerformed(java.awt.event.ActionEvent e) {
b = !b;
bouton.setLabel(b ? "Cliquez ici" : "ici zeuqilC");
}
}
|
Java définit un ensemble d'interfaces pour la gestion des évènements
graphiques;
toutes ces interfaces sont dérivées de l'interface vide
java.util.EventListener.
Chacune de ces interfaces est composée d'une ou de plusieurs méthodes.
Par exemple, comme nous l'avons déjà vu
précédemment,
l'interface MouseListener permet la gestion des actions
de la souris sur un composant graphique. Cette interface contient
les méthodes suivantes:
public void mouseClicked(MouseEvent e)
public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
public void mouseEntered(MouseEvent e)
public void mouseExited(MouseEvent e)
|
Un composant graphique qui est à l'écoute des évènements de la souris
doit implanter
cette interface MouseListener. En implantant cette interface,
on définit les
opérations que l'on veut voir effectuer à chacune des actions de
l'utilisateur sur la souris.
Comme pour la souris, d'autres interfaces permettent la gestion de
l'ensemble des évènements qui peuvent survenir dans une application
graphique.
Un composant graphique qui est à l'écoute d'un évènement de la souris
doit implanter l'interface MouseListener i.e. donner une
implantation pour les toutes les méthodes de l'interface. Or, bien
souvent, un composant ne s'intéresse pas à tous les évènements
possibles mais qu'à un nombre limité d'entre eux. Par exemple, un
bouton peut s'intéresser qu'au fait de cliquer. Dans ces cas, le
composant qui implante
l'interface MouseListener doit fournir l'implantation de
toutes les méthodes
de cette interface. Ce qui conduit le programmeur à fournir tout
un ensemble de méthode vide.
public class Click1 extends java.applet.Applet implements java.awt.event.MouseListener {
java.awt.Button bouton;
boolean b = true;
public void init() {
bouton = new java.awt.Button("Cliquez ici");
add("Center", bouton);
bouton.addMouseListener(this);
}
public void mousePressed(java.awt.event.MouseEvent e) {
b = !b;
bouton.setLabel(b ? "Cliquez ici" : "ici zeuqilC");
}
public void mouseClicked(java.awt.event.MouseEvent e) {}
public void mouseReleased(java.awt.event.MouseEvent e) {}
public void mouseEntered(java.awt.event.MouseEvent e) {}
public void mouseExited(java.awt.event.MouseEvent e) {}
}
|
Pour éviter cette inflation de méthodes vides, Java fournit,
pour certaines
des ces interfaces, une classe qui l'implante avec des méthodes vides.
Par exemple, la classe MouseAdapter est définie comme suit:
public class MouseAdapter implements MouseListener {
public void mouseClicked(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
}
|
Il suffit alors de se définir une sous classe de l'une de celles-ci et
de ne redéfinir que les méthodes qui nous intéressent.
Que si l'on veut pas hériter d'une classe adaptateur.
N'oublions pas que Java ne permet que l'héritage simple.
class SourisAdaptateur extends java.awt.event.MouseAdapter {
Click2 c;
public SourisAdaptateur(Click2 c) {
super();
this.c = c;
}
public void mousePressed(java.awt.event.MouseEvent e) {
c.b = !c.b;
c.bouton.setLabel(c.b ? "Cliquez ici" : "ici zeuqilC");
}
}
public class Click2 extends java.applet.Applet {
java.awt.Button bouton;
boolean b = true;
public void init() {
bouton = new java.awt.Button("Cliquez ici");
add("Center", bouton);
bouton.addMouseListener(new SourisAdaptateur(this));
}
}
|
Cette approche est hélas lourde et une meilleur approche
consiste à utiliser
les classes imbriquées.
public class Click3 extends java.applet.Applet {
java.awt.Button bouton;
boolean b = true;
public void init() {
bouton = new java.awt.Button("Cliquez ici");
add("Center", bouton);
bouton.addMouseListener(new SourisAdaptateur());
}
class SourisAdaptateur extends java.awt.event.MouseAdapter {
public void mousePressed(java.awt.event.MouseEvent e) {
b = !b; bouton.setLabel(b ? "Cliquez ici" : "ici zeuqilC");
}
}
}
|
Une autre manière de gérer les évènement est fournie
dans AWT . Il s'agit de de gérer de manière globale les
évènements:
- une méthode protected void processEvent(AWTEvent e) de
la classe Component qui en fonction de l'argument e
capture les évènements.
- des méthodes spécifique selon le type d'évènements:
- protected void processActionEvent(ActionEvent e)
- protected void processAdjustmentEvent(AdjustmentEvent e)
- protected void processComponentEvent(ComponentEvent e)
- protected void processComponentKeyEvent(KeyEvent e)
- protected void processContainerEvent(ContainerEvent e)
- protected void processFocusEvent(FocusEvent e)
- protected void processInputMethodEvent(InputMethodEvent e)
- protected void processItemEvent(ItemEvent e)
- protected void processKeyEvent(KeyEvent e)
- protected void processMouseEvent(MouseEvent e)
- protected void processTextEvent(TextEvent e)
- protected void processWindowEvent(WindowEvent e)
Il est important de noter lorsqu'on redéfinit l'une de ses
méthodes dans un container,
il ne faut pas oublier d'invoquer la méthode de même nom
dans la classe père.
protected void processActionEvent(ActionEvent e) {
// Faire ce qu'il faut
...
super.processActionEvent(e);
}
|
Comme pour les EventListener , il faut pour pouvoir gérer
les évènements par cette méthode, être à l'écoute des évènements
qui nous intéressent; ce qui se fait en invoquant la méthode
protected final void enableEvents(long typeEvent). Le
paramètre typeEvent est un masque de bits:
- ACTION_EVENT_MASK
- ADJUSTMENT_EVENT_MASK
- COMPONENT_EVENT_MASK
- CONTAINER_EVENT_MASK
- FOCUS_EVENT_MASK
- ITEM_EVENT_MASK
- KEY_EVENT_MASK
- MOUSE_EVENT_MASK
- MOUSE_MOTION_EVENT_MASK
- TEXT_EVENT_MASK
- WINDOW_EVENT_MASK
public class Click4 extends java.applet.Applet {
UnButton bouton1;
UnButton bouton2;
public void init() {
bouton1 = new UnButton();
bouton2 = new UnButton();
add(bouton1);
add(bouton2);
}
}
class UnButton extends java.awt.Button {
boolean b = true;
public UnButton() {
super("Cliquez ici");
enableEvents(java.awt.AWTEvent.MOUSE_EVENT_MASK);
}
protected void processMouseEvent(java.awt.event.MouseEvent e) {
if (e.getID() == java.awt.event.MouseEvent.MOUSE_CLICKED) {
b = !b;
setLabel(b ? "Cliquez ici" : "ici zeuqilC");
System.out.println("kjh");
}
}
}
|
A quelques rares exceptions près, il n'est généralement pas
nécessaire de gérer les évènements de cette manière.
Vous trouverez un exemple d'utilisation avec les
PopupMenu (voir ).
L'interface ActionListener est l'interface
la plus simple d'utilisation.
Elle est composée d'une unique méthode actionPerformed.
Interface java.awt.event.ActionListener extends EventListener {
public void actionPerformed(ActionEvent e);
}
|
Cette méthode est invoquée lorsque l'un des évènements suivants survient:
- clic sur un bouton (java.awt.Button)
- double clic sur un élément d'une liste (java.awt.List)
- choix d'un élément d'un menu (java.awt.MenuItem)
- retour chariot sur un champ texte (java.awt.TextField)
Les instances de la classe java.awt.event.ActionEvent contiennent
des informations sur l'évènement.
public class java.awt.event.ActionEvent extends java.awt.AWTEvent {
public static final int SHIFT_MASK
public static final int CTRL_MASK
public static final int META_MASK
public static final int ALT_MASK
public static final int ACTION_FIRST
public static final int ACTION_LAST
public static final int ACTION_PERFORMED
public ActionEvent(Object source, int id, String command)
public ActionEvent(Object source, int id, String command, int modifiers)
public String getActionCommand()
public int getModifiers()
public String paramString()
}
|
public String getActionCommand ()
Retourne la chaîne de caractères associées à l'évènement.
public String getModifiers ()
Retourne un entier représentant le ou les ``modifier keys'' enfoncés lors de la survenue de l'évènement.
public String paramString ()
A terminer
Les interfaces MouseListener et MouseMotionListener
permettent la gestion de la souris pour un composant donnée.
Pour des raisons d'efficacité (la gestion du déplacement
de la souris étant plus
lourde que la simple gestion des clics), la gestion de la
souris est divisée en deux:
- l'interface MouseListener s'occupe de la
position par rapport
au composant et des actions simples de la souris (clic)
Interface java.awt.event.MouseListener extends EventListener {
public void mouseClicked(MouseEvent e)
public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
public void mouseEntered(MouseEvent e)
public void mouseExited(MouseEvent e)
}
|
import java.applet.Applet;
import java.awt.*;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
public class Mouse extends Applet implements MouseListener {
TextArea textArea;
ZoneVierge blankArea;
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(false);
add(textArea);
blankArea = new ZoneVierge(new Color(0.98f, 0.97f, 0.85f));
add(blankArea);
blankArea.addMouseListener(this);
}
public void mousePressed(MouseEvent e) {
afficher("MousePressed; nbre of clics: " + e.getClickCount(), e);
}
public void mouseReleased(MouseEvent e) {
afficher("MouseReleased; nbre of clics: " + e.getClickCount(), e);
}
public void mouseEntered(MouseEvent e) {
afficher("MouseEntered", e);
}
public void mouseExited(MouseEvent e) {
afficher("MouseExited", e);
}
public void mouseClicked(MouseEvent e) {
afficher("MouseClicked (nbre of clics: " + e.getClickCount() + ")", e);
}
void afficher(String eventDescription, MouseEvent e) {
textArea.append(eventDescription + System.getProperty("line.separator"));
textArea.setCaretPosition(2000);
}
}
|
- l'interface MouseMotionListener
s'occupe la gestion du déplacement de la souris
Interface java.awt.event.MouseMotionListener extends EventListener {
public void mouseDragged(MouseEvent e)
public void mouseMoved(MouseEvent e)
}
|
Toutes ces méthodes ont un unique paramètre qui une
instance de la classe MouseEvent.
public class java.awt.event.MouseEvent extends java.awt.InputEvent {
public static final int MOUSE_FIRST
public static final int MOUSE_LAST
public static final int MOUSE_CLICKED
public static final int MOUSE_PRESSED
public static final int MOUSE_RELEASED
public static final int MOUSE_MOVED
public static final int MOUSE_ENTERED
public static final int MOUSE_EXITED
public static final int MOUSE_DRAGGED
public MouseEvent(Component source, int id, long when, int modifiers,
int x, int y, int clickCount, boolean popupTrigger)
public int getX()
public int getY()
public Point getPoint()
public void translatePoint(int x, int y)
public int getClickCount()
public boolean isPopupTrigger()
public String paramString()
}
|
public int getX ()
Retourne l'abscisse de la position (relativement au composant)
de l'évènement.
public int getY ()
Retourne l'ordonnée de la position (relativement au composant)
de l'évènement.
public Point getPoint ()
Retourne la position (relativement au composant) de l'évènement.
public void translatePoint (int x, int y)
A terminer
public int getClickCount ()
Retourne le nombre de clics survenus.
public boolean isPopupTrigger ()
A terminer
Cette applet est une feuille de dessin simplifiée pour faire des dessins
à main levée avec la souris. On reparlera de cet applet dans
le chapitre 28.
public class Draw extends java.applet.Applet {
int x=0, y=0;
public Draw() {
super();
setBackground(java.awt.Color.cyan);
addMouseListener(new java.awt.event.MouseAdapter() {
public void mousePressed(java.awt.event.MouseEvent e) {
x = e.getX(); y = e.getY();
}
});
addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
public void mouseDragged(java.awt.event.MouseEvent e) {
java.awt.Graphics g = getGraphics();
g.drawLine(x, y, e.getX(), e.getY());
x = e.getX(); y = e.getY();
}
});
}
}
|
Remarque surle DnD
L'interface KeyListener permette la gestion du
clavier pour un composant donnée.
Les évènements clavier surviennent lorsque l'utilisateur
effectue une frappe clavier.
L'évènement est reçu par le composant en premier plan
(celui qui a le focus ).
Interface java.awt.event.KeyListener extends EventListener {
public void keyTyped(KeyEvent e)
public void keyPressed(KeyEvent e)
public void keyReleased(KeyEvent e)}
|
Toutes ces méthodes ont un unique paramètre qui une instance de la classe KeyEvent.
public class java.awt.event.KeyEvent extends java.awt.InputEvent {
public static final int KEY_FIRST, KEY_LAST, KEY_TYPED, KEY_PRESSED
public static final int KEY_RELEASED, VK_ENTER, VK_BACK_SPACE, VK_TAB
public static final int VK_CANCEL, VK_CLEAR, VK_SHIFT, VK_CONTROL, VK_ALT
public static final int VK_PAUSE, VK_CAPS_LOCK, VK_ESCAPE, VK_SPACE
public static final int VK_PAGE_UP, VK_PAGE_DOWN, VK_END, VK_HOME
public static final int VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN
public static final int VK_COMMA, VK_PERIOD, VK_SLASH
public static final int VK_0, ... VK_9;
public static final int VK_SEMICOLON, VK_EQUALS
public static final int VK_A, ..., VK_Z
public static final int VK_OPEN_BRACKET, VK_BACK_SLASH, VK_CLOSE_BRACKET
public static final int VK_NUMPAD0, ..., VK_NUMPAD9
public static final int VK_MULTIPLY, VK_ADD, VK_SEPARATER, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE
public static final int VK_F1, ..., VK_F12
public static final int VK_DELETE, VK_NUM_LOCK, VK_SCROLL_LOCK
public static final int VK_PRINTSCREEN, VK_INSERT, VK_HELP, VK_META
public static final int VK_BACK_QUOTE, VK_QUOTE, VK_KP_UP, VK_KP_DOWN
public static final int VK_KP_LEFT, VK_KP_RIGHT, VK_DEAD_GRAVE, VK_DEAD_ACUTE
public static final int VK_DEAD_CIRCUMFLEX, VK_DEAD_TILDE, VK_DEAD_MACRON, VK_DEAD_BREVE
public static final int VK_DEAD_ABOVEDOT, VK_DEAD_DIAERESIS, VK_DEAD_ABOVERING
public static final int VK_DEAD_DOUBLEACUTE, VK_DEAD_CARON, VK_DEAD_CEDILLA
public static final int VK_DEAD_OGONEK, VK_DEAD_IOTA, VK_DEAD_VOICED_SOUND
public static final int VK_DEAD_SEMIVOICED_SOUND, VK_AMPERSAND, VK_ASTERISK
public static final int VK_QUOTEDBL, VK_LESS, VK_GREATER, VK_BRACELEFT
public static final int VK_BRACERIGHT, VK_FINAL, VK_CONVERT, VK_NONCONVERT
public static final int VK_ACCEPT, VK_MODECHANGE, VK_KANA, VK_KANJI, VK_UNDEFINED
public static final char CHAR_UNDEFINED
public KeyEvent(Component source, int id, int modifiers, int keyCode, char keyChar)
public KeyEvent(Component source, int id, long when, int modifiers, int keyCode)
public int getKeyCode()
public void setKeyCode(int keyCode)
public void setKeyChar(char keyChar)
public void setModifiers(int modifiers)
public char getKeyChar()
public static String getKeyText(int keyCode)
public static String getKeyModifiersText(int modifiers)
public boolean isActionKey()
public String paramString()
}
|
public char getKeyChar ()
A terminer
public static String getKeyText (int keyCode)
A terminer
public static String getKeyModifiersText (int modifiers)
A terminer
public boolean isActionKey ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
public class Key extends Applet implements KeyListener {
TextArea textArea;
TextField textField;
String rc = System.getProperty("line.separator");
public void init() {
textArea = new TextArea(20, 50);
textArea.setEditable(false);
textArea.setBackground(new Color(0.98f, 0.97f, 0.85f));
add(textArea);
textField = new TextField(20);
add(textField);
textField.addKeyListener(this);
}
public void keyTyped(KeyEvent e) { afficher("KeyTyped " + rc + decoder(e)); }
public void keyPressed(KeyEvent e) { afficher("KeyPressed " + rc + decoder(e)); }
public void keyReleased(KeyEvent e) { afficher("KeyReleased " + rc + decoder(e)); }
String decoder(KeyEvent e) {
char car = e.getKeyChar();
String carStr = Character.isISOControl(car) ? "???" : "'"+ car + "'";
int code = e.getKeyCode();
String codeStr = KeyEvent.getKeyText(code);
int modif = e.getModifiers();
String modifStr = KeyEvent.getKeyModifiersText(modif);
if (modifStr.length() == 0) modifStr = "Aucun";
return "\tCode = " + codeStr + rc + "\tCar " + carStr + rc + "\tModif " + modifStr ;
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
}
|
Les évènements de l'interface WindowListener sont générés lorsqu'une
fenêtre s'ouvre (windowOpened), se ferme (windowClosing et
windowClosed), s'iconifie (windowIconified), se déiconifie
(windowDeiconified), devient active (windowActivated)
ou inactive (windowDeactivated).
Interface java.awt.event.WindowListener extends EventListener {
public void windowOpened(WindowEvent e)
public void windowClosing(WindowEvent e)
public void windowClosed(WindowEvent e)
public void windowIconified(WindowEvent e)
public void windowDeiconified(WindowEvent e)
public void windowActivated(WindowEvent e)
public void windowDeactivated(WindowEvent e)
}
|
Toutes ces méthodes ont un unique paramètre qui une
instance de la classe WindowEvent.
public class java.awt.event.WindowEvent extends java.awt.ComponentEvent {
public static final int WINDOW_FIRST
public static final int WINDOW_LAST
public static final int WINDOW_OPENED
public static final int WINDOW_CLOSING
public static final int WINDOW_CLOSED
public static final int WINDOW_ICONIFIED
public static final int WINDOW_DEICONIFIED
public static final int WINDOW_ACTIVATED
public static final int WINDOW_DEACTIVATED
public WindowEvent(Window source, int id)
public Window getWindow()
public String paramString()
}
|
public WindowEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Fenetre extends Applet implements WindowListener, ActionListener {
java.awt.Button b;
TextArea textArea;
Frame fenetre;
String rc = System.getProperty("line.separator");
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(false);
add(textArea);
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new Frame("Une fenetre");
fenetre.setSize(300, 100);
fenetre.setBackground(new Color(0.98f, 0.97f, 0.85f));
fenetre.addWindowListener(this);
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public void windowClosing(WindowEvent e) {
afficher("windowClosing");
fenetre.setVisible(false);
}
public void windowOpened(WindowEvent e) { afficher("windowOpened"); }
public void windowIconified(WindowEvent e) { afficher("windowIconified"); }
public void windowDeiconified(WindowEvent e) { afficher("windowDeIconified"); }
public void windowActivated(WindowEvent e) { afficher("windowActivated"); }
public void windowDeactivated(WindowEvent e) { afficher("windowDeactivated"); }
public void windowClosed(WindowEvent e) { }
}
|
L'interface ComponentListener et la classe
ComponentAdapter
permettent de gérer les évènements concernant les
caractéristiques d'un composant: taille,
déplacement et visibilité. Comme d'habitude,
un composant qui veut gérer ces évènements
s'inscrit avec la méthode addComponentListener.
Interface java.awt.event.ComponentListener extends EventListener {
public void componentResized(ComponentEvent e)
public void componentMoved(ComponentEvent e)
public void componentShown(ComponentEvent e)
public void componentHidden(ComponentEvent e)
}
|
Toutes ces méthodes ont un unique paramètre qui une instance
de la classe ComponentEvent.
public class java.awt.event.ComponentEvent extends java.awt.AWTEvent {
public static final int COMPONENT_FIRST
public static final int COMPONENT_LAST
public static final int COMPONENT_MOVED
public static final int COMPONENT_RESIZED
public static final int COMPONENT_SHOWN
public static final int COMPONENT_HIDDEN
public ComponentEvent(Component source, int id)
public Component getComponent()
public String paramString()
}
|
public ComponentEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Composant extends Applet implements WindowListener, ComponentListener, ActionListener {
java.awt.Button b;
TextArea textArea;
Frame fenetre;
String rc = System.getProperty("line.separator");
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(true);
add(textArea);
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new Frame("Une fenetre");
fenetre.setSize(300, 100);
fenetre.setBackground(new Color(0.98f, 0.97f, 0.85f));
fenetre.addWindowListener(this);
fenetre.addComponentListener(this);
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public void windowClosing(WindowEvent e) { fenetre.setVisible(false); }
public void windowOpened(WindowEvent e) { }
public void windowIconified(WindowEvent e) { }
public void windowDeiconified(WindowEvent e) { }
public void windowActivated(WindowEvent e) { }
public void windowDeactivated(WindowEvent e) { }
public void windowClosed(WindowEvent e) { }
public void componentResized(ComponentEvent e) { afficher("componentResized"); }
public void componentMoved(ComponentEvent e) { afficher("componentMoved"); }
public void componentShown(ComponentEvent e) { afficher("componentShown"); }
public void componentHidden(ComponentEvent e) { afficher("componentHidden"); }
}
|
Un composant peut être à l'écoute de l'ajout (add)
et/ou de la suppression (remove) d'autre composants.
Interface java.awt.event.ContainerListener extends EventListener {
public void componentAdded(ContainerEvent e)
public void componentRemoved(ContainerEvent e)
}
|
public class java.awt.event.ContainerEvent extends java.awt.ComponentEvent {
public static final int CONTAINER_FIRST
public static final int CONTAINER_LAST
public static final int COMPONENT_ADDED
public static final int COMPONENT_REMOVED
public ContainerEvent(Component source, int id, Component child)
public Container getContainer()
public Component getChild()
public String paramString()
}
|
public ContainerEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Container extends Applet implements ActionListener, ContainerListener {
private static final int MAX = 10;
java.awt.Button ajout, suppression;
TextArea textArea;
String rc = System.getProperty("line.separator");
Button [] tab = new Button[MAX];
int sommet = 0;
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(false);
add(textArea);
ajout = new Button("Ajouter un composant");
ajout.setActionCommand("Ajouter");
add(ajout);
ajout.addActionListener(this);
suppression = new Button("Supprimer un composant");
suppression.setActionCommand("Supprmier");
add(suppression);
suppression.addActionListener(this);
addContainerListener(this);
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand() == "Ajouter") {
if (sommet < MAX) { add(tab[sommet++] = new Button("B"+(sommet+1))); validate(); }
}
else if (sommet > 0) { remove(tab[--sommet]); tab[sommet] = null; validate(); }
}
public void componentAdded(ContainerEvent e) { afficher("On ajoute le bouton " + e.getChild().getName()); }
public void componentRemoved(ContainerEvent e) { afficher("On supprime le bouton " + e.getChild().getName()); }
}
|
Ces évènements sont générés lorsqu'un composant
devient actif (focus) ou passif.
Interface java.awt.event.FocusListener extends EventListener {
public void focusGained(FocusEvent e)
public void focusLost(FocusEvent e)
}
|
public class java.awt.event.FocusEvent extends java.awt.ComponentEvent {
public static final int FOCUS_FIRST
public static final int FOCUS_LAST
public static final int FOCUS_GAINED
public static final int FOCUS_LOST
public FocusEvent(Component source, int id, boolean temporary)
public FocusEvent(Component source, int id)
public boolean isTemporary()
public String paramString()
}
|
public FocusEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Focus extends Applet implements FocusListener, ActionListener {
TextArea textArea;
Button b;
Frame fenetre;
String rc = System.getProperty("line.separator");
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(true);
add(textArea);
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new Frame("Une fenetre");
fenetre.setSize(300, 100);
fenetre.setBackground(new Color(0.98f, 0.97f, 0.85f));
fenetre.setVisible(false);
fenetre.addFocusListener(this);
fenetre.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { fenetre.setVisible(false); }
});
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
public void focusGained(FocusEvent e) { afficher("focusGained "); }
public void focusLost(FocusEvent e) { afficher("focusLost "); }
}
|
Les évènements de l'interface TextListener
sont générés lorsqu'un
composant de type texte (TextArea et
TextField) subissent des changements.
Interface java.awt.event.TextListener extends EventListener {
public void textValueChanged(TextEvent e)
}
|
public class java.awt.event.TextEvent extends java.awt.AWTEvent {
public static final int TEXT_FIRST
public static final int TEXT_LAST
public static final int TEXT_VALUE_CHANGED
public TextEvent(Object source, int id)
public String paramString()
}
|
public TextEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Text extends Applet implements TextListener, ActionListener {
TextArea textArea;
TextArea TA;
TextField TF;
String rc = System.getProperty("line.separator");
public void init() {
textArea = new TextArea(5, 50);
textArea.setEditable(false);
add(textArea);
TF = new TextField(50);
TF.setEditable(true);
add(TF);
TA = new TextArea(3, 50);
TA.setEditable(false);
add(TA);
TA.addTextListener(this);
TF.addTextListener(this);
TF.addActionListener(this);
}
void afficher(String s) {
textArea.append(s + rc);
textArea.setCaretPosition(2000);
}
public void textValueChanged(TextEvent e) {
TextComponent tc = (TextComponent)e.getSource();
String s = tc.getText();
afficher("textValueChanged sur " + ((tc==TA) ? "TextArea " : "TextField ") + " " + s);
}
public void actionPerformed(ActionEvent e) {
TextComponent tc = (TextComponent)e.getSource();
String s = tc.getText();
if (s.equals("")) return;
TA.append(s + rc);
TA.setCaretPosition(2000);
TF.setText("");
}
}
|
Les évènements de l'interface ItemListener sont générés par
les composant qui implantent l'interface ItemSelectable
(Checkbox, MenuItem,
Choice et list)
Interface java.awt.event.ItemListener {
public void itemStateChanged(ItemEvent e)
}
|
public class java.awt.event.ItemEvent extends java.awt.AWTEvent {
public static final int ITEM_FIRST
public static final int ITEM_LAST
public static final int ITEM_STATE_CHANGED
public static final int SELECTED
public static final int DESELECTED
public ItemEvent(ItemSelectable source, int id, Object item, int stateChange)
public ItemSelectable getItemSelectable()
public Object getItem()
public int getStateChange()
public String paramString()
}
|
public ItemEvent ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Item extends Applet implements ActionListener {
TextArea textArea;
String rc = System.getProperty("line.separator");
MesChoix meschoix;
MesCases mescases; MaListe maliste;
public void init() {
textArea = new TextArea(8, 50);
textArea.setEditable(false);
add(textArea);
meschoix = new MesChoix(this);
mescases = new MesCases(this);
maliste = new MaListe(this);
Button b = new Button("OK");
add(meschoix); add(mescases); add(maliste); add(b);
b.addActionListener(this);
}
void afficher(String s) { textArea.append(s + rc); textArea.setCaretPosition(2000); }
public void actionPerformed(ActionEvent e) {
afficher("Votre Choix ");
afficher("\tRegion " + meschoix.getSelectedItem());
afficher("\tAnnee " + maliste.getSelectedItem());
afficher("\tType " + mescases.getSelectedCheckbox());
}
}
class MesChoix extends Choice implements ItemListener {
Item t;
public MesChoix(Item t) {
super();
this.t = t;
addItem("Bordeaux"); addItem("Bourgogne"); addItem("Alsace"); addItem("Cotes du Rhones");
addItemListener(this);
}
public void itemStateChanged(ItemEvent e) { t.afficher("itemStateChanged " + e.getItem()); }
}
class MaListe extends List implements ItemListener {
Item t;
MaListe(Item t) {
super();
this.t = t;
add("1991"); add("1992"); add("1993"); add("1994"); add("1995"); add("1996");
addItemListener(this);
}
public void itemStateChanged(ItemEvent e) { t.afficher("itemStateChanged " + e.getItem()); }
}
class MesCases extends Container implements ItemListener {
Item t;
CheckboxGroup cbg;
public MesCases(Item t) {
super();
this.t = t;
cbg = new CheckboxGroup();
Checkbox c1 = new Checkbox("Rouge", cbg, true);
Checkbox c2 = new Checkbox("Rose", cbg, false);
Checkbox c3 = new Checkbox("Blanc", cbg, false);
add(c1); add(c2); add(c3);
c1.addItemListener(this); c2.addItemListener(this); c3.addItemListener(this);
}
public String getSelectedCheckbox() { return cbg.getSelectedCheckbox().getLabel(); }
public void itemStateChanged(ItemEvent e) { t.afficher("itemStateChanged " + e.getItem()); }
}
|
L'interface AdjustmentListener est celle qui permet
la gestion des ascenseurs (java.awt.ScrollBar).
Interface java.awt.event.AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e)
}
|
public class java.awt.event.ActionEvent extends java.awt.AWTEvent {
public static final int ADJUSTMENT_FIRST
public static final int ADJUSTMENT_LAST
public static final int ADJUSTMENT_VALUE_CHANGED
public static final int UNIT_INCREMENT
public static final int UNIT_DECREMENT
public static final int BLOCK_DECREMENT
public static final int BLOCK_INCREMENT
public static final int TRACK
public AdjustmentEvent(Adjustable source, int id, int type, int value)
public Adjustable getAdjustable()
public int getValue()
public int getAdjustmentType()
public String paramString()
}
|
public AdjustmentEvent (Adjustable source, int id, int type, int value)
A terminer
public Adjustable getAdjustable ()
Retourne la source de l'évènement; remplace la méthode getSource.
public int getAdjustmentType ()
Retourne le type de l'évènement qui est
l'un des constantes: UNIT_INCREMENT,
UNIT_DECREMENT, BLOCK_INCREMENT, BLOCK_DECREMENT, TRACK.
public int getValue ()
Rtourne la valeur du composant après que l'évènement se soit produit.
public String paramString ()
A terminer
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Adjustment extends Applet implements AdjustmentListener {
TextField tf;
SC scb;
public void init() {
scb = new SC();
tf = new TextField(3);
add(scb); add(tf);
scb.addAdjustmentListener(this);
tf.setEditable(false);
tf.setText("50");
}
public void adjustmentValueChanged(AdjustmentEvent e) { tf.setText(Integer.toString(e.getValue())); }
}
class SC extends Scrollbar {
Dimension minSize;
public SC() {
super(Scrollbar.HORIZONTAL, 50, 1, 0, 200);
minSize = new Dimension(150, 15);
}
public Dimension getPreferredSize() { return getMinimumSize(); }
public synchronized Dimension getMinimumSize() { return minSize; }
}
|
a partir de 1.2
L'interface InputMethodListener se charge de la gestion de
l'édition des composants de type texte
(TextField et TextArea).
Interface java.awt.event.InputMethodListener extends EventListener {
public void inputMethodTextChanged(InputMethodEvent event)
public void caretPositionChanged(InputMethodEvent event)
}
|
public class java.awt.event.InputMethodEvent extends java.awt.AWTEvent {
public static final int INPUT_METHOD_FIRST
public static final int INPUT_METHOD_TEXT_CHANGED
public static final int CARET_POSITION_CHANGED
public static final int INPUT_METHOD_LAST
public static final int ALL_CHARACTERS_COMMITTED
public InputMethodEvent(Component source, int id,
AttributedCharacterIterator text, int committedCharacterCount,
TextHitInfo caret, TextHitInfo visiblePosition)
public InputMethodEvent(Component source, int id, TextHitInfo caret,
TextHitInfo visiblePosition)
public AttributedCharacterIterator getText()
public int getCommittedCharacterCount()
public TextHitInfo getCaret()
public TextHitInfo getVisiblePosition()
public void consume()
public boolean isConsumed()
}
|
public InputMethodEvent ()
A terminer
| |
Action |
Adjust. |
Compon. |
Contain. |
Focus |
Item |
Key |
Mouse |
MouseMot. |
Text |
Window Button |
A TERMINER
A TERMINER
Next: 26 Les widgets
Up: Java: Programmation graphique
Previous: 24 Découvrir la programmation
Touraivane
6/12/1998