• Sources d’événements :

C'est l'origine de l'événement. A titre d’exemple, un clic de la souris sur un composant bouton génère une instance de la class ActionEvent. Cette une instance contient des informations sur le statut de l’événement par exemple :

- getActionCommand() : renvoie le nom de commande associé à l’action.
- getModifiers() : renvoie la combinaison des "modificateurs", c’est à dire la combinaison des touches que l’on a maintenues pressées pendant le click (touche Shift par exemple).
- getSource() : rend l’objet qui a généré l’événement.

• Gestionnaire d’événements

Un gestionnaire (handler en anglais) d’événement est une méthode qui reçoit un objet de type Event, l’analyse et traite les conséquences de l’interaction utilisateur.Pour certains types d’événements il peut y avoir plusieurs types de gestionnaires qui seront respectivement appelés en fonction de l’action qui s’est produite au niveau du composant source. Ainsi pour un événement souris on pourra distinguer un gestionnaire correspondant à l’action du “clic” ou un gestionnaire correspondant au fait que le curseur soit passé sur le composant concerné.

Modèle par délégation

Le JDK 1.1 a introduit dans Java un modèle d’événement appelé modèle d’événement par délégation. Dans un modèle d’événement par délégation, les événements sont (indirectement) générés par un composant graphique (qualifié de “source” de l’événement); on doit associer à ce composant un objet de traitement d’événement (appelé veilleur: Listener) pour recevoir l’événement et le traiter. De cette façon, le traitement d’événement peut figurer dans une classe distincte du composant impliqué.

Un “veilleur” est susceptible de traiter plusieurs actions liées à un type d’événement et donc de disposer de plusieurs gestionnaires : par exemple un gestionnaire chargé de veiller sur les “clics” souris et un chargé de veiller sur le passage de la souris sur le composant.

Exemple de mise en place de traitement d’événement

A titre d’exemple, voici une fenêtre (TestButton.java) simple comportant un seul bouton :

TestButton.java

import java.awt.*;
import javax.swing.*;

public class TestButton {
	public static void main(String args[]) {
		JFrame fr = new JFrame("Test");
		JButton bt = new JButton("Appuyer!");
		//On enregistre un veilleur de type "VeilleurBouton" au bouton 
		bt.addActionListener(new VeilleurBouton());
		fr.getContentPane().add(bt, BorderLayout.CENTER);
		fr.pack();
		fr.setVisible(true);
	}
}

Puis on définit la classe de notre VeilleurBouton (VeilleurBouton.java), cette classe doit implémenter une interface (une déclaration de type qui permet de décrire une capacité) pour l'obliger d'implanter le code correspondant aux méthodes déclarées mais cela lui permettra d’être “vue” comme conforme au contrat de type exigé. Le choix de l'interface d'épand de la catégorie des événements (voir lite suivante) et parfois de composants.

Pour notre veilleur nous allons implémenter l'interface ActionListener pour définir une action sur le buttons.

VeilleurBouton.java

import java.awt.event.*;

public class VeilleurBouton implements ActionListener {
	public void actionPerformed(ActionEvent evt) {
		System.err.println("Aïe!sur " + evt.getActionCommand());
		/*
		 * faire System.err.println dans un interface graphique n’est pas
		 * fondamentalement une bonne idée! ceci est un exemple
		 */
	}
}

Exemple de personnalisation un événement

Le modèle d'événement Java nous permet de créer facilement nos propres événements, pour cela nous allons procéder en 3 étapes :

• Listener : créer une interface (MyEventListener.java) pour que notre veilleur l'implémente et ainsi il sera obligé de définir ses méthodes. Cette interface doit hérite de EventListener l'interface de description que touts les veilleurs doivent étendre.
  

MyEventListener.java

import java.util.EventListener; public interface MyEventListener extends EventListener { /** * La méthode que le veilleur doit redéfinir. * Le traitement à réaliser quand l'événement est généré c'est à dire * quand la valeur de l'objet change. * @param e une instance de type MyEvent */ public abstract void onValueChange(MyEvent e); }




• Event : créer une class fille(MyEvent.java) de la classe mère EventObject dont tous les objets d'événements devront hériter pour les personnaliser en fonction de nos besoins.

MyEvent.java

import java.util.EventObject; public class MyEvent extends EventObject { /** * Constructeur de l'événement. * Pour instancier des objets MyEvent. * @param source une instance de type MyComponent, la source de l'événement. */ public MyEvent(MyComponent source) { super(source); } @Override public MyEvent getSource() { return getSource(); } @Override public String toString() { return source.toString(); } /** * Retourne le nom de la source de l'événement. * @return le nom de la source as String */ public String getName() { return getSource().getName(); } }




• Component : Créer la classe (MyComponent.java) pour définir les objets qui vont générer des événements, comme pour les boutons par exemple.

MyComponent.java

import java.util.Vector; public class MyComponent { /** * Liste pour stocker tous les veilleurs de ce composant. */ private Vector listenersList = new Vector(); /** * Le nom du composant. */ private String name=""; /** * La valeur du composant. */ private int value = 0; /** * Constructeur du composant. * @param name le nom du composant. */ public MyComponent(String name) { this.name=name; } /** * Retourne le nom du composant * @return le nom du composant as String */ public String getName() { return name; } /** * Modife la valeur du composant. * @param value la nouvelle valeur du composant. */ public void setValue(int value) { this.value = value; notifValueChange(); } /** * Retourne la valeur du composant * @return la valeur du composant as int */ public int getValue() { return value; } /** * Pour notifier tous les veilleurs de ce composant du * changement de sa valeur. */ protected void notifValueChange() { MyEvent e = new MyEvent(this); for (int i = 0; i < listenersList.size(); i++) { MyEventListener l = (MyEventListener) listenersList.elementAt(i); l.onValueChange(e); } } /** * Enregistrement d'un veilleur dans la Liste. * @param l un veilleur définit par l'interface MyEventListener */ public synchronized void addStockListener(MyEventListener l) { listenersList.addElement(l); } /** * Suppression d'un veilleur de la liste. * @param l un veilleur définit par l'interface MyEventListener */ public synchronized void removeStockListener(MyEventListener l) { listenersList.removeElement(l); } @Override public String toString() { return name + " " + value; } }

Pour terminer nous allons crée une interface graphique (IHM.java) pour tester notre événement.

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;

public class IHM extends JFrame implements MyEventListener {
	private JPanel contentPane;

	private JTextArea texte = new JTextArea();

	private JPanel panel = new JPanel();

	private JSlider slider = new JSlider();

	private MyComponent component;

	public IHM(String name) {

		contentPane = (JPanel) this.getContentPane();
		contentPane.setLayout(new BorderLayout());
		contentPane.add(texte, BorderLayout.CENTER);
		contentPane.add(panel, BorderLayout.NORTH);
		panel.add(slider, null);

		slider.setValue(0);
		slider.addChangeListener(new ChangeListener() {
			public void stateChanged(ChangeEvent e) {
				component.setValue(slider.getValue());
			}
		});
		component = new MyComponent(name);
		// On enregistre le veilleur au composant
		component.addStockListener(this);

		this.setSize(new Dimension(309, 94));
		this.setTitle("IHM Event");
		setVisible(true);

	}

	// On définit le traitement à faire en cas de changement de valeur
	public void onValueChange(MyEvent e) {
		texte.setText(e.toString());
	}

	public static void main(String args[]) {
		new IHM("Component name");
	}
}

Télécharger l'archive complet de ce tutoriel (Event.zip)