Flash: ascolta tutti gli eventi di un tipo con un listener di eventi

Question

Non è una questione di vita o di morte, ma mi chiedo se questo potrebbe essere possibile:

Ho ricevuto un paio di eventi da un tipo di evento personalizzato (FormEvent) ora ho un FormListener che ascolta tutti quegli eventi e li gestisce in base al tipo di evento. Invece di aggiungere un EventListener al momento, desidero aggiungere tutti gli eventi contemporaneamente.

quindi ora sembra così:

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

ma invece di aggiungere ogni evento uno alla volta preferirei fare qualcosa del genere

    private function addListeners():void {

        addEventListener(FormEvent.*, formListener);
    }

Mi chiedo se sia possibile qualcosa di simile, mi piacerebbe. Lavoro con molti eventi :)

Answer 1

In questo caso in realtà è necessario solo un listener di eventi. Quel listener ascolterà qualsiasi modifica con il modulo e un parametro uguale a quello che era la modifica diventa disponibile per la funzione listener di eventi. Ti mostrerò, ma per favore ricorda che questa è una pseudo situazione e normalmente non spedirei un evento da qualcosa di semplice come una chiamata di metodo perché la spedizione è implicita, quindi non c'è bisogno di ascoltarla.

Prima l'evento personalizzato

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

Quindi abbiamo appena creato la nostra classe di eventi personalizzati e l'abbiamo impostata in modo da poter rilevare lo stato attraverso la funzione listener come dimostrerò una volta fatto con la classe di pseudo form che invierà il suddetto evento personalizzato.

Ricorda che tutto ciò è ipotetico in quanto non ho idea di come sia il tuo codice o di come stai implementando. L'importante è notare che quando invio l'evento devo inviare un parametro che rifletta quale sia il nuovo stato.

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

E infine creiamo la classe di documenti che la ascolterà. Per favore sappi che mi rendo conto che non è logico creare un ascoltatore che si attiva quando chiami un metodo di una classe perché ovviamente sai che hai chiamato il metodo, ma per questo esempio sarà dovuto.

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

Spero che sia stato utile, è tardi e potrei dover rivedere alcune cose in seguito, ma ciò dovrebbe aiutare a capire come organizzare i tuoi eventi e personalizzare come funzionano le cose.

Answer 2

Non conosco routine che ti permettano di farlo direttamente, ma potresti scriverne uno tuo. La sintassi qui non sarà perfetta, ma ecco un primo passo:

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

Potresti quindi chiamare quella routine in questo modo:

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