Flash: Hören Sie alle Ereignisse eines Typs mit einem Eventlistener

Question

Es ist nicht eine Frage von Leben oder Tod, aber ich frage mich, ob dies möglich sein könnte:

Ich habe ein paar Ereignisse von einer Art von benutzerdefinierten Ereignisses (FormEvent) jetzt habe ich eine FormListener, die für alle diese Ereignisse zuhört und behandelt sie entsprechend dem Ereignistyp. Statt einer eventlistener zum Zeitpunkt der Zugabe wünsche ich auf einmal alle Ereignisse hinzuzufügen.

so jetzt sieht es wie folgt aus:

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

aber statt jeden Fall ein zu der Zeit das Hinzufügen würde ich eher so etwas wie

tun

    private function addListeners():void {

        addEventListener(FormEvent.*, formListener);
    }

Ich frage mich, ob so etwas möglich ist, würde ich es lieben. Ich arbeite mit vielen Veranstaltungen:)

Answer 1

Sie müssen nur wirklich ein Ereignis-Listener in diesem Fall sowieso. Das Hörer wird mit dem Formular für jede Änderung zuzuhören und einen Parameter gleich, was die Änderung wird war die Ereignis-Listener-Funktion zur Verfügung. Ich zeige Ihnen, aber bitte denken Sie daran, dass dies eine Pseudo-Situation ist und normalerweise würde ich kein Ereignis auslösen weg von etwas so einfach wie ein Methodenaufruf, da der Versand impliziert ist, so gibt es keine wirkliche Notwendigkeit, es zu hören ist.

Zuerst wird das Kundenspezifischer Ereignis

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

So haben wir nur unsere eigene Ereignisklasse erstellt und wir haben es so eingerichtet, dass wir den Zustand durch die Listener-Funktion fangen können, wie ich einmal mit der Pseudo-Formularklasse getan demonstrieren, dass die für das benutzerdefinierte Ereignis versenden.

Denken Sie daran, dass dies alles hypothetisch, da ich keine Ahnung, was wie oder wie Sie Ihre Implementierung Dinge, die Ihr Code sieht. Was wichtig ist, ist zu bemerken, dass, wenn ich das -Ereignis Ich brauche einen Parameter, mit ihm zu senden, das widerspiegelt, was der neue Zustand ist.

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

Und schließlich schaffen wir die Dokumentenklasse, die für sie hören. Bitte beachten Sie, dass ich weiß, es ist nicht logisch, einen Zuhörer zu erstellen, die ausgelöst wird, wenn Sie eine Methode einer Klasse nennen, weil man natürlich wissen, dass Sie die Methode genannt, aber für dieses Beispiel wird es fällig.

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

Ich hoffe, dass dies hilfreich, seine spät und ich kann später einige Dinge überarbeiten müssen, aber das sollte helfen, ein Verständnis davon, wie Sie Ihre eigenen Veranstaltungen zu machen und anpassen, wie die Dinge funktionieren.

Answer 2

Ich weiß nicht, von irgendwelchen Routinen, können Sie das tun direkt, aber Sie können Ihre eigene schreiben. Die Syntax hier wird nicht perfekt sein, aber hier ist ein erster Durchlauf:

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

Sie könnten dann rufen die Routine wie folgt:

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