Flash: Écoutez tous les événements d'un type avec un seul eventlistener

Question

Ce n’est pas une question de vie ou de mort, mais je me demande si cela pourrait être possible:

J'ai eu quelques événements d'un type d'événement personnalisé (FormEvent). J'ai maintenant un FormListener qui écoute tous ces événements et les traite en fonction du type d'événement. Au lieu d'ajouter un seul eventListener à la fois, je souhaite ajouter tous les événements à la fois.

alors maintenant ça ressemble à ça:

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

mais au lieu d'ajouter chaque événement un à la fois, je préférerais faire quelque chose comme

    private function addListeners():void {

        addEventListener(FormEvent.*, formListener);
    }

Je me demande si quelque chose comme cela est possible, j'aimerais bien. Je travaille avec des tas d’événements:)

Answer 1

De toute façon, vous n’avez vraiment besoin que d’un écouteur d’événements. Cet écouteur sera à l'écoute de tout changement avec le formulaire et un paramètre égal à ce que le changement était devenu disponible pour la fonction d'écouteur d'événements. Je vais vous montrer, mais s'il vous plaît rappelez-vous qu'il s'agit d'une pseudo-situation et que normalement je n'enverrais pas un événement d'une chose aussi simple que l'appel d'une méthode car l'envoi est implicite, il n'est donc pas vraiment nécessaire de l'écouter.

D'abord l'événement personnalisé

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

Nous venons donc de créer notre classe d'événements personnalisée et de la configurer pour pouvoir capturer l'état par le biais de la fonction d'écoute, comme je le démontrerai une fois avec la classe de pseudo formulaire qui enverra le pour cet événement personnalisé.

N'oubliez pas que tout cela est hypothétique car je n'ai aucune idée de ce à quoi ressemble votre code ni de la façon dont vous implémentez les choses. Ce qui est important, c’est de remarquer que lorsque je distribue l’événement, j’ai besoin de lui envoyer un paramètre qui reflète l’état du nouvel état.

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

Et finalement, nous créons la classe de document qui l'écoutera. Sachez que je réalise qu’il n’est pas logique de créer un écouteur qui se déclenche lorsque vous appelez une méthode de classe, car vous savez évidemment que vous avez appelé la méthode, mais pour cet exemple, elle sera due.

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

J'espère que cela a été utile, qu'il est tard et qu'il faudra peut-être réviser certaines choses plus tard, mais cela devrait vous aider à comprendre comment créer vos propres événements et à personnaliser le fonctionnement.

Answer 2

Je ne connais aucune routine vous permettant de le faire directement, mais vous pouvez écrire la vôtre. La syntaxe ici ne sera pas parfaite, mais voici un premier passage:

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

Vous pouvez ensuite appeler cette routine comme suit:

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