Evénements génériques et paramètres supplémentaires dans Actionscript 3.0?

Question

En supposant que le schéma suivant:

someObjectInstance.addEventListener(MyDisplayObject.EVENT_CONSTANT, _handleMyEvent); 


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

Si je voulais ajouter un paramètre nécessaire à la fonction de gestionnaire, je suis en mesure de le faire et toujours utiliser un événement « générique » et auditeur événement? Ou ai-je raison de supposer que j'ai besoin de créer une classe d'événement personnalisée qui contient le paramètre et qui fait référence à l'objet d'événement passé dans la fonction de gestionnaire?

Pour cette phrase une autre façon ... Si j'ai une fonction de gestionnaire qui ressemble à ceci:

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

Alors qu'est-ce que le besoin de ressembler à la fonction addEventListener? Y a-t-il une syntaxe plus avancée? Y a-t-il un moyen de faire cela avec des fermetures?

Recherche d'un exemple de code clair et/ou d'une référence de documentation. Juste essayer de comprendre si je dois absolument remplacer la classe générique d'événement dans ce scénario.

Answer 1

Si vous avez besoin de données personnalisées pour voyager avec votre événement, vous devez créer une classe d'événements personnalisée.

Voici un exemple 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); 
     } 
    } 
} 

S'il vous plaît noter que la méthode clone est obligatoire. Vous devez avoir cette méthode dans votre classe personnalisée pour que votre événement soit diffusé à nouveau correctement (par exemple, lorsqu'un objet reçoit l'événement, puis le redistribue comme il est propre).

Maintenant, comme pour l'envoi de l'événement, cela fonctionnerait comme ceci (évidemment ce code irait dans une méthode de classe qui étend EventDispatcher).

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

Et enfin, abonnez-vous à l'événement:

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

foo.addEventListener(ColorEvent.CHANGE_COLOR, onChangeColor); 

Answer 2

Il y a une façon de transmettre des données personnalisées à la méthode de gestionnaire sans créer un événement personnalisé.

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

Attendez une minute, tout le monde. Voir this answer.

Vous n'avez absolument pas besoin de personnaliser quoi que ce soit pour référencer le paramètre via l'écouteur. Donc, oui, Gordon, vous pouvez le faire avec votre écouteur d'événements et d'événements moyen.

Et c'est très simple! La fonction addEventListener reste la même. Son écoute est ce qui sera ajusté:

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

Aucune syntaxe avancée, mais un concept relativement avancé: variable functions. Vous pouvez faire des fermetures avec ce que nous avons ici, mais vous n'en aurez absolument pas besoin. Et comme ça, vous n'aurez absolument pas besoin de surcharger la classe Event. J'espère que ces exemples et cette documentation clarifient pour vous!