## Manipular Eventos en el BeanBox

Los Beans utilizan el mecanismo de eventos implementado en el JDK 1.1, por eso implementar eventos en los Beans es igual que implementar eventos en cualquier componente del JDK 1.1. Esta sección describe como se utiliza este mecanismo de eventos en los Beans y en el BeanBox.

### Cómo descubre el BeanBox las capacidades de Eventos de un Beans

El BeanBox utiliza la introspección de patrones de diseño o una clase BeanInfo para descubir los eventos que puede disparar un Bean.

#### Utilizar la Introspección para Descubrir los Eventos Lanzados por un Bean

Los JavaBeans proporcionan patrones de diseño orientados a eventos para dar a las herramientas de introspección la posibilidad de descubir los eventos que puede lanzar un Bean.

Para que un Bean sea la fuente de un evento, debe implementar métodos que añadan y eliminen oyentes para el tipo del objeto. Los patrones de diseño para esos métodos son

    public void add<EventListenerType>(<EventListenerType> a)
    public void remove<EventListenerType>(<EventListenerType> a)

Estos métodos le permiten a un Bean fuente saber donde lanzar los eventos. Entonces el Bean fuente lanza los eventos a aquellos Beans oyentes que utilicen los métodos para aquellos interfaces particulares. Por ejemplo, si un Bean fuente registra objetos ActionListener, lanzará eventos a dichos objetos llamando al método actionPerformed() de dichos oyentes.

Para ver los eventos descubiertos utilizando patrones de diseño, arrastra un ejemplar de OurButton dentro del BeanBox y despliega el menú Edit|Events. Esto muestra una lista de interface de eventos que OurButton puede disparar. Observa que el propio OurButton sólo añade dos de esos interfaces; el resto son heredados de la clase base.

#### Utilizar BeanInfo para Definir los Eventos Lanzados por el Bean

Se pueden "publicar" explícitamente los eventos lanzados por un Bean, utilizando una clase que implementa el interface BeanInfo. El Bean ExplicitButton subclasifica OurButton, y proporciona una clase ExplicitButtonBeanInfo asociada. ExplicitButtonBeanInfo implementa el siguiente método para definir explícitamente los interfaces que ExplicitButton utiliza para lanzar eventos.

    public EventSetDescriptor[] getEventSetDescriptors() {
        try {
            EventSetDescriptor push = new EventSetDescriptor(beanClass,
                        "actionPerformed",
                        java.awt.event.ActionListener.class,
                        "actionPerformed");

            EventSetDescriptor changed = new EventSetDescriptor(beanClass,
                        "propertyChange",
                        java.beans.PropertyChangeListener.class,
                        "propertyChange");

            push.setDisplayName("button push");
            changed.setDisplayName("bound property change");

            EventSetDescriptor[] rv = { push, changed};
            return rv;
        } catch (IntrospectionException e) {
            throw new Error(e.toString());
        }
    }

Arrastra un ejemplar de ExplicitButton al BeanBox, y despliega el menú Edit|Events. Observa que sólo se listan aquellos interfaces expuestos explícitamente en la clase ExplicitButtonBeanInfo. No se exponen las capacidades heredadas. Puedes ver la página El Interface BeanInfo para más información sobre este interface.

#### Ver los Eventos de un Bean en el BeanBox

Si has seleccionado un Bean OurButton en el BeanBox, despliega el menú Edit|Events, verás una lista de interfaces a los que OurButton puede lanzar eventos. Cuando se selecciona algún interface, se muestran los métodos que lanzan diferentes eventos a dichos interfaces. Estos corresponden a todos los eventos que OurButton puede lanzar

### Capturando Eventos en el BeanBox

En este ejemplo utilizaremos dos ejemplares del Bean OurButton para arrancar y parar un ejemplar del Bean Juggler animado. Etiquetaremos esto botones como "start" y "stop"; haremos que cuando se pulse el botón "start" se llame al método startJuggling del Bean Juggler; y que cuando se pulse el botón "stop", se llame al método stopJuggling del Bean Juggler.

1. Arrancar el BeanBox.
2. Arrastra un Bean Juggler y dos ejemplares de OurButton en el BeanBox.
3. Selecciona un ejemplar de OurButton. En la hoja de propiedades, cambia la etiqueta a "start".
4. Selecciona el segundo ejemplar de OurButton y cambia su etiqueta a "stop".
5. Seleciona el botón start. elige el menú Edit|Events|action|actionPerformed. Esto hace que aparezca una linea marcada entre el botón start y el cursor. Pulsar sobre el ejemplar de Juggler. Esto trae el EventTargetDialog:

   Esta lista contiene los métodos de Juggler que no toman argumentos, o argumentos del tipo actionPerformed.

6. Selecciona el método startJuggling y pulsa OK. Verás un mensaje indicando que el BeanBox está generando una clase adaptador.
7. repite los dos últimos pasos sobre el botón stop, excepto en elegir el método stopJuggling en el EventTargetDialog.

Si pulsas ahora sobre los botones start y stop se arrancará y parará la ejecución de Juggler. Aquí tienes una descripción general de lo que ha sucedido:

- Los botones start y stop son fuentes de eventos. Las fuentes de eventos lanzan eventos a los destinos de eventos. En este ejemplo el Bean Juggler es el Destino del Evento.
- Cuando se selecciona el botón start y se elige un método de evento (mediante el menú Edit|Event), se está eligiendo el tipo de evento que lanzará la fuente del evento.
- cuando se conecta la línea con otro Bean, estás seleccionando el Bean Destino del evento.
- El EventTargetDialog lista los métodos que pueden aceptar ese tipo de eventos o que no tomen parámetros. Cuando se elige un método en el EventTargetDialog, se está eligiendo el método que recibirá el evento lanzado, y actuará sobre él.

Utiliza el menú File|Save pará grabar este ejemplo en un fichero de tu elección.

### Clases Adpatadoras de Eventos

El BeanBox genera una clase adpatador que se interpone entre la fuente y el destino del evento. La clase adaptador implementa el interface del oyente de evento apropiado (como el oyente real), captura el evento lanzado por el botón, y llama al método seleccionado del bean destino. Aquí tienes la clase adpatador generada por el BeanBox que se interpone entre el botón start y el JugglerBean:

    // Automatically generated event hookup file.

    package tmp.sunw.beanbox;
    import sunw.demo.juggler.Juggler;
    import java.awt.event.ActionListener;
    import java.awt.event.ActionEvent;

    public class ___Hookup_1474c0159e implements
               java.awt.event.ActionListener, java.io.Serializable {

        public void setTarget(sunw.demo.juggler.Juggler t) {
            target = t;
        }

        public void actionPerformed(java.awt.event.ActionEvent arg0) {
            target.startJuggling(arg0);
        }

        private sunw.demo.juggler.Juggler target;
    }

El adaptador implementa el interface ActionListener que se ha seleccionado en el menú Edit|Events del BeanBox. ActionListener declare un método, actionPerformed(), que es implementado por el adaptador para llamar al método del Bean destino (startJuggling()) que se ha seleccionado. El método setTarget() del adaptador es llamado por el BeanBox para seleccionar el Bean destino real, en este caso Juggler.

### El Bean EventMonitor

El Bean EventMonitor (beans/demo/sunw/demo/encapsulatedEvents) imprime informes de los eventos del Bean fuente, en un listbox. Para ver como funciona esto, sigue estos pasos:

1. Arrastra ejemplares de OurButton y EventMonitor hasta el BeanBox. Podrías redimensionar el EventMonitor (y el BeanBox) para acomodar la visión de los informes de eventos.
2. Selecciona el ejemplar de OurButton, y elige cualquier método en el menú Edit|Events.
3. Conecta la línea que aparece con el EventMonitor, y elige su initiateEventSourcMonitoring en el EventTargetDialog.
4. Selecciona el Bean OurButton. Estarás viendo un informe de eventos en el EventMonitor

Cuando el primer evento es enviado, EventMonitor analiza el Bean fuente para descubrir todos los eventos que lanza, crea y registra oyentes de eventos para cada tipo de evento, y luego informa siempre que se lance un evento. Esto es útil para depuración, Intenta conectar otros Beans a EventMonitor para observar sus eventos.

### Eventos para Propiedades Compartidas y Restringidas

Las páginas sobre propiedades Compartidas y Restringidas describen dos interfaces de oyentes de eventos específicos.

Ozito