En el nuevo modelo de eventos, los eventos son generados por fuentes de ventos. Uno o más oyentes pueden registrarse para ser notificados sobre los eventos de un tipo particular sobre una fuente particular. Algunas veces este modelo es llamado delegación, ya que permite al programador delegar la autoridad del manejo del evento a cualquier objeto que implemente el interface de oyente apropiado. El nuevo modelo de eventos del AWT de permite tanto manejar como generar eventos AWT.

Los manejadores de eventos pueden ser ejemplares de cualquier clase. Siempre que una clase implemente el interface de oyente de eventos, sus ejemplares pueden manejar eventos. En todo programa que tenga un manejador de eventos, veras tres trozos de código:

1. En la sentencoa class del manejador de eventos, El código que declara que la clase implementa un interace oyente (o extiende una clase que implementa el interface oyente). Por ejemplo:

   public class MiClase implements ActionListener {
   

2. El código que registra un ejemplar de la clase manejadora de eventos como un oyente para uno o más componentes. Por ejemplo:

   someComponent.addActionListener(instancedeMiClase);
   

3. La implementación de métodos en el interface oyente. Por ejemplo:

   public void actionPerformed(ActionEvent e) {
       ...//código que reacciona a la acción...
   }
   

Un ejemplo sencillo

Aquí tienes un applet del 1.1 que ilustra el manejo de eventos. Contiene un sólo botón que hace un Beep cuando lo pulsas.

Puedes encontrar el programa completo en Beeper.java. Aquí sólo el código que implementa el manejo de eventos para el botón:

public class Beeper ... implements ActionListener {
    ...
    //Donde ocurre la inicialización:
        button.addActionListener(this);
    ...
    public void actionPerformed(ActionEvent e) {
        ...//Hace un sonido Beep...
    }
}

¿No es sencillo? La clase Beeper implementa el interface ActionListener, que contiene un método: actionPerformed.

Cómo Beeper implementa ActionListener, un objeto Beeper puede registrarse como oyente de los eventos de acción que generen los botones. Una vez que Beeper ha sido registrado utilizando el método addActionListener del button, el método actionPerformed del Beeper es llamado cada vez que se pulsa el botón.

Un ejemplo más complejo

El modelo de eventos del 1.1 que has podido ver en su forma más sencilla en el ejemplo anterior, es bastante poderoso y flexible. Cualquier número de objetos oyentes puede escuchar todas las clases de eventos desde cualquier número de objetos fuentes. Por ejemplo, un programa podría crear un oyente para cada fuente de evento. O un programa podría tener un sólo oyente para todos los eventos de todas las fuentes. Incluso un programa puede tener más de un oyente para una sola clase de evento desde un sólo objeto fuente.

El siguiente applet ofrece un ejemplo de utilización de múltiples oyentes por objeto. El applet contiene dos funtes de eventos (ejemplares de Button y dos oyentes de eventos. Uno de los oyentes (un ejemplar de la clase llamada MultiListiner escucha los eventos de los dos botones. Cuando recibe un evento, añade el "comando de acción" del evento (el texto de la etiqueta del botón) en la parte superior del área de texto. El segundo oyente (un ejemplar de la clase llamada Eavesdropper) escuchas los eventos de uno sólo de los botones. Cuando recibe un evento, añade el comando de acción en la parte inferior del área de texto.

Puedes encontrar el programa completo en MultiListener.java. Aquí sólo tienes el código que implementa el manejo de eventos para el botón:

public class MultiListener ... implements ActionListener {
    ...
    //donde ocurra la inicialización:
        button1.addActionListener(this);
        button2.addActionListener(this);

        button2.addActionListener(new Eavesdropper(bottomTextArea));
    }

    public void actionPerformed(ActionEvent e) {
        topTextArea.append(e.getActionCommand() + "\n");
    }
}

class Eavesdropper implements ActionListener {
    ...
    public void actionPerformed(ActionEvent e) {
        myTextArea.append(e.getActionCommand() + "\n");
    }
}

En el código anterior, tanto MultiListener como Eavesdropper immplementan el interface ActionListener y se registran como oyentes de acción utilizando el método addActionListener de la clase Button. La implementación del método actionPerformed en ambas clases es similar: sólo añaden el comando de acción al área de texto.

Un ejemplo de manejo de eventos de otro tipo

Hasta ahora, la única clase de eventos que has vista han sido los eventos action. Echemos un vistazo a un programa que maneja otra clase de eventos: eventos del ratón.

El siguiente applet muestra un rectángulo elevado y un área de texto. Cuando ocurre un evento delratón -- un click, pulsación, liberación, entrar o salid -- dentro del área del rectángulo (BlankAreaMouseDemo), el área de texto muestra la cadena que describe el evento.

Puedes encontrar el programa completo en MouseDemo.java. Aquí sólo está el código que implementa el manejo de eventos:

public class MouseDemo ...  implements MouseListener {
    ...
    //Donde ocurra la inicialización:
        //Registra lo eventos del ratón en blankArea y applet (panel).
        blankArea.addMouseListener(this);
        addMouseListener(this);
    }

    public void mousePressed(MouseEvent e) {
       saySomething("Mouse button press", e);
    }

    public void mouseReleased(MouseEvent e) {
       saySomething("Mouse button release", e);
    }

    public void mouseEntered(MouseEvent e) {
       saySomething("Cursor enter", e);
    }

    public void mouseExited(MouseEvent e) {
       saySomething("Cursor exit", e);
    }

    public void mouseClicked(MouseEvent e) {
       saySomething("Mouse button click", e);
    }

    void saySomething(String eventDescription, MouseEvent e) {
        textArea.append(eventDescription + " detected on "
                        + e.getComponent().getClass().getName()
                        + ".\n");
        textArea.setCaretPosition(maxInt); //hack to scroll to bottom
    }
}

Podrás ver el código explicado en Implementar un oyente del Ratón.

---

Ozito