Flash: escuche todos los eventos de un tipo con un eventlistener

Question

No es una cuestión de vida o muerte, pero me pregunto si esto podría ser posible:

Obtuve un par de eventos de un tipo de evento personalizado (FormEvent). Ahora tengo un FormListener que escucha todos esos eventos y los maneja de acuerdo con el tipo de evento. En lugar de agregar un eventListener al momento, deseo agregar todos los eventos a la vez.

así que ahora se ve así:

        private function addListeners():void {

        addEventListener(FormEvent.SHOW_FORM, formListener);
        addEventListener(FormEvent.SEND_FORM, formListener);
        addEventListener(FormEvent.CANCEL_FORM, formListener);
    }



        private function formListener(event:formEvent):void {

        switch(event.type){
            case "show.form": 
                // handle show form stuff
            break;
            case "send.form":
                // handle send form stuff
            break;
            case "cancel.form":
                // handle cancel form stuff
            break;
        }
    }

pero en lugar de agregar cada evento uno en el momento, preferiría estar haciendo algo así como

    private function addListeners():void {

        addEventListener(FormEvent.*, formListener);
    }

Me pregunto si algo como esto es posible, me encantaría. Trabajo con muchos eventos :)

Answer 1

De todos modos, solo necesitas un detector de eventos en este caso. Ese oyente escuchará cualquier cambio con el formulario y un parámetro igual a lo que el cambio estuvo disponible para la función de escucha de eventos. Le mostraré, pero recuerde que esto es una pseudo situación y normalmente no enviaría un evento de algo tan simple como una llamada de método porque el envío está implícito, por lo que no hay necesidad real de escucharlo. p>

Primero el evento personalizado

package com.yourDomain.events
{
    import flash.events.Event;
    public class FormEvent extends Event
    {
        //Public Properties
        public static const CANCEL_FORM:int = "0";
        public static const SHOW_FORM:int = "1";
        public static const SEND_FORM:int = "2";

        public static const STATE_CHANGED:String = "stateChanged";

        //Private Properties
        private var formState:int;

        public function FormEvent(formState:int):void
        {
            super(STATE_CHANGED);
            formState = formState;
        }
    }
}

Así que acabamos de crear nuestra clase de evento personalizado y la hemos configurado para que podamos capturar el estado a través de la función de escucha, como demostraré una vez hecho con la clase de pseudo formulario que enviará el evento personalizado para dicho evento personalizado.

Recuerda que todo esto es hipotético, ya que no tengo idea de cómo se ve tu código ni de cómo implementas las cosas. Lo que es importante es notar que cuando envío el evento necesito enviar un parámetro que refleje cuál es el nuevo estado.

package com.yourDomain.ui
{
   import flash.events.Event;
   import flash.events.EventDispatcher;
   import com.yourDomain.events.FormEvent;
   public class Form extends EventDispatcher
   {
     public function Form():void
     {
        //Anything you want form to do upon instantiation goes here.
     }
     public function cancelForm():void
     {
        dispatchEvent(new Event(FormEvent.CANCEL_FORM);
     }
     public function showForm():void
     {
        dispatchEvent(new Event(FormEvent.SHOW_FORM);
     }
     public function sendForm():void
     {
        dispatchEvent(new Event(FormEvent.SEND_FORM);
     }
   }
}

Y finalmente creamos la clase de documento que la escuchará. Tenga en cuenta que me doy cuenta de que no es lógico crear un oyente que se active cuando llama a un método de una clase porque obviamente sabe que llamó al método, pero para este ejemplo será necesario.

package com.yourDomain.ui
{
   import com.yourDomain.ui.Form;
   import com.yourDomain.events.FormEvent;
   //Form is in the same package so we need not import it.
   public class MainDocumentClass
   {
      private var _theForm:Form;

      public function MainDocumentClass():void
      {
         _theForm  = new Form();
         _theForm.addEventListener(FormEvent.STATE_CHANGED, onFormStateChange, false, 0, true);
         /*
         The following three method calls each cause the
         FormEvent.STATE_CHANGE event to be dispatched.  
         onFormStateChange is notified and checks what 
         the last change actually was.
         */
         _theForm.cancelForm();
         _theForm.showForm();
         _theForm.sendForm();
      }
      private function onFormStateChange(e:FormEvent):void
      {
         switch(e.formState)
         {
            case CANCEL_FORM:
              trace('The form was canceled');
              break;
            case SHOW_FORM:
              trace('The form was revealed');
              break;
            case SEND_FORM:
              trace('The form was sent');
              break;
         }
      }
   }      
}

Espero que esto haya sido útil, que sea tarde y que tenga que revisar algunas cosas más adelante, pero esto debería ayudar a comprender cómo hacer tus propios eventos y personalizar cómo funcionan las cosas.

Answer 2

No conozco ninguna rutina que te permita hacerlo directamente, pero puedes escribir el tuyo. La sintaxis aquí no será perfecta, pero aquí hay un primer paso:

private function addMultipleEventListeners( evts:Array, callback:function ):void
{
    for each( var evt:Event in evts )
    {
        addEventListener( evt, callback );
    }
}

Entonces podrías llamar a esa rutina así:

var evts:Array = [ FormEvent.SHOW_FORM, FormEvent.SEND_FORM, FormEvent.CANCEL_FORM ];
addMultipleEventListeners( evts, formListener );