next up previous contents index
Next: 26 Les widgets Up: Java: Programmation graphique Previous: 24 Découvrir la programmation

Subsections

25 Gestion des évènements

     

25.1 Le modèle évènementiel de Java

 

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.

25.1.1 Les objets évènement

   

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

25.1.2 Les objets récepteurs

 

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).

25.1.3 Les objets émetteurs ou sources

 

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

25.1.4 Un premier exemple

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

}

25.2 La gestion des évènements graphiques

       

La gestion des évènements graphiques suit le schémas général que nous venons d'exposer:

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:

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

25.2.1 Les évènements prédéfinis

       

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.

                     

                     

Interface Méthodes ActionListener

25.2.2 Les classes adaptateurs

   

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.

             

             

Interface Classe adaptateur ActionListener

25.2.3 Les classes imbriquées

   

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

25.2.4 Gestion d'évènements pour composants étendus

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:

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:

 

   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 ).

25.2.5 L'interface ActionListener et la classe ActionEvent

         

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:

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

25.2.6 Les interfaces MouseListener, MouseMotionListener et la classe MouseEvent

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:

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

Votre browser ne peut exécuter les applets Java

 

Remarque surle DnD

25.2.7 L'interface KeyListener et la classe KeyEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.8 L'interface WindowListener et la classe WindowEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.9 L'interface ComponentListener et la classe ComponentEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.10 L'interface ContainerListener et la classe ContainerEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.11 L'interface FocusListener et la classe FocusEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.12 L'interface TextListener et la classe TextEvent

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.13 L'interface ItemListner et la classe ItemEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.14 L'interface AdjustmentListener et la classe AdjustmentEvent

         

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

Votre browser ne peut exécuter les applets Java

 

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

25.2.15 L'interface InputMethodListener et la classe InputMethodEvent

 

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

25.3 Récapitulatif des évènements associés aux composants

  Action Adjust. Compon. Contain. Focus Item Key Mouse MouseMot. Text Window Button

25.3.1 Suppression de la gestion des évènements

 

A TERMINER

25.3.2 La queue d'évènements

 

A TERMINER


next up previous contents index
Next: 26 Les widgets Up: Java: Programmation graphique Previous: 24 Découvrir la programmation
Touraivane
6/12/1998