¿Eventos genéricos y parámetros adicionales en Actionscript 3.0?

actionscript-3 events

Question

Suponiendo el siguiente patrón:

someObjectInstance.addEventListener(MyDisplayObject.EVENT_CONSTANT, _handleMyEvent);


private function _handleMyEvent( event:Event = null ):void
{
  // Event handler logic...
}

Si quisiera agregar un parámetro requerido a la función del controlador, ¿puedo hacer esto y seguir usando un evento "genérico" y un detector de eventos? ¿O estoy en lo correcto al asumir que necesito crear una clase de evento personalizada que tenga el parámetro y hacer referencia a eso a través del objeto de evento pasado a la función de controlador?

Para decirlo de otra manera ... Si tengo una función de controlador que se ve así:

private function _handleMyEvent( data:Object, event:Event = null ):void
{
  if (data == null)
  {
      return;
  }
  // Event handler logic...
}

Entonces, ¿cómo debe ser la función addEventListener? ¿Hay una sintaxis más avanzada? ¿Hay alguna manera de hacer esto con cierres?

Buscando un ejemplo de código claro y / o referencia de documentación. Solo trato de entender si tengo que anular la clase de evento genérica en este escenario.

Answer 1

Espera un minuto, todos. Vea esta respuesta .

No necesita personalizar nada para hacer referencia al parámetro a través del oyente. Entonces, sí, Gordon, puedes hacer esto con tu oyente de eventos y eventos promedio.

¡Y es muy simple! La función addEventListener se mantiene igual. Su oyente es lo que se ajustará:

var functionHandleMyEvent:Function = _handleMyEvent(data);
someObjectInstance.addEventListener(MyDisplayObject.EVENT_CONSTANT, functionHandleMyEvent);
// Later, when you need to remove it, do:
//someObjectInstance.removeEventListener(MyDisplayObject.EVENT_CONSTANT, functionHandleMyEvent);

private function _handleMyEvent(data:Object):Function {
  return function(event:Event):void {
    if (data == null) {
      // Event handler logic here now has both "event" and "data" within your reach
    }
  }
}

Sin sintaxis avanzada, pero un concepto relativamente avanzado: funciones variables . Puedes hacer cierres con lo que tenemos aquí, pero absolutamente no necesitarás hacerlo. Y así, también absolutamente no necesitarás anular la clase Event.

¡Espero que estos ejemplos y documentación te aclaren!

Answer 2

Hay una manera de pasar datos personalizados al método del controlador sin crear un evento personalizado.

private function test() {
    var data : SomeObject = new SomeObject;
    var a:SomeEventDispatcher = new SomeEventDispatcher();
    a.addEventListener(Event.COMPLETE, handle(data));   
    a.dispatchCompleteEvent();
}

private function handle(data : SomeObject) : Function {
    return function(e : Event) : void {
       IEventDispatcher(e.target).removeEventListener(Event.COMPLETE, arguments.callee);
       trace(e + ", " + data);
    };
}

Answer 3

Si necesita datos personalizados para viajar con su evento, sí, necesita crear una clase de evento personalizada.

Aquí hay un ejemplo simple:

package {
    import flash.events.Event;

    public class ColorEvent extends Event {
        public static const CHANGE_COLOR:String = "ChangeColorEvent";

        public var color:uint;

        public function ColorEvent(type:String, color:uint, bubbles:Boolean = false, cancelable:Boolean = false) {
            this.color = color;
            super(type, bubbles, cancelable);
        }

        override public function clone():Event {
            return new ColorEvent(type, color, bubbles, cancelable);
        }
    }
}

Tenga en cuenta que el método de clonación NO es opcional. Debe tener este método en su clase personalizada para que su evento sea retransmitido alguna vez (digamos cuando un objeto recibe el evento y luego lo vuelve a distribuir como si fuera propio).

Ahora, en cuanto al envío del evento, funcionaría así (obviamente este código iría en un método de clase que amplía EventDispatcher).

dispatchEvent(new ColorEvent(ColorEvent.CHANGE_COLOR, 0xFF0000));

Y finalmente, suscribirse al evento:

function onChangeColor(event:ColorEvent):void {
    trace(event.color);
}

foo.addEventListener(ColorEvent.CHANGE_COLOR, onChangeColor);