Est-il un moyen de supprimer inconnu des écouteurs d'événement à partir d'objets?

Je veux avoir une réutilisables bouton qui peut être inscrit à l'un des nombreux différents rappels, déterminé par une source externe. Lorsqu'une nouvelle fonction de rappel est définie, je veux supprimer l'ancienne. Je veux aussi être en mesure d'effacer le rappel de l'extérieur à tout moment.

public function registerButtonCallback(function:Function):void
{
  clearButtonCallback();

  button.addEventListener(MouseEvent.CLICK, function, false, 0, true);
}

public function clearButtonCallback():void
{
  if (button.hasEventListener(MouseEvent.CLICK) == true)
  {
    //do something to remove that listener
  }
}

J'ai vu des suggestions sur ici pour utiliser les "arguments.le destinataire de l'appel" dans le rappel, mais je ne veux pas avoir cette fonctionnalité liée à la fonction de rappel - par exemple, je pourrais voulez être en mesure de cliquer sur le bouton deux fois.

Suggestions?

InformationsquelleAutor | 2008-10-08
  1. 8

    Je suis en supposant que vous souhaitez uniquement une fonction de rappel à un moment donné. Si c'est le cas, alors pourquoi ne pas avoir une seule fonction de rappel associé à l'événement click sur le bouton qui lui-même appelle une fonction et que la fonction d'être réglable...

    <mx:Button click="doCallback()" .../>

public var onClickFunction:Function = null;
private function doCallback():void
{
    if (onClickFunction != null)
    {
        onClickFunction(); //optionally you can pass some parameters in here if you match the signature of your callback
    }
}

    Un consommateur de votre contrôle qui abrite votre bouton définir le onClickFunction avec la fonction appropriée. En fait, vous pouvez l'installer aussi souvent que vous avez aimé.

    Si vous voulez aller plus loin, vous pourriez créer des sous-classes AS3 Touche de classe et envelopper tout cela à l'intérieur.

    • Gotcha. Vous savez, je pense que j'ai commencé à le faire et a décidé contre elle pour une raison dont je ne me souviens pas. De toute façon, votre présomption est correct et c'est un bon moyen de faire ce que j'ai prévu. Merci.
    • Super, content d'avoir pu aider. Si vous marquez ce que la réponse que je vais avoir un peu de points de rep trop 🙂
    InformationsquelleAutor Simon
  2. 4

    Pas. Vous avez besoin pour maintenir une référence à l'auditeur pour l'enlever. À moins que vous stocker une référence à la fonction d'écoute à l'avance, il n'est pas publique documenté méthode pour récupérer une telle référence d'un EventDispatcher.

    addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
dispatchEvent(event:Event):Boolean
hasEventListener(type:String):Boolean
removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
willTrigger(type:String):Boolean

    Comme vous pouvez le voir, il existe deux méthodes pour vous dire si un type d'événement a un écouteur ou un de ses parents a un écouteur, mais aucune de ces méthodes retournent, en réalité, une liste d'auditeurs.

    Maintenant s'il vous plaît aller harceler Adobe pour la rédaction d'un tel inutile de l'API. Fondamentalement, ils vous donnent la possibilité de savoir "si", le flux d'événements a changé, mais ils vous donnent pas moyen de faire quelque chose avec cette information!

    InformationsquelleAutor Triynko
  3. 3

    Magasin de l'auditeur comme un accessoire. Quand un autre événement est ajouté, vérifiez pour voir si l'auditeur, et si c'est le cas, appelez removeEventListener.

    Sinon, remplacer la méthode addEventListener de vous bouton. Lorsque la méthode addEventListener est appelé, magasin de la fermeture avant de l'ajouter à l'événement dans un objet Dictionary. Lorsque la méthode addEventListener est appelée de nouveau, supprimer: 

    
var listeners:Dictionary = new Dictionary();
    


    override public function addEventListener( type : String, listener : Function, useCapture : Boolean = false, priority : int = 0, useWeakReference : Boolean = false) : void {
    


      if( listeners[ type ] ) {

     if( listeners[ type ] [ useCapture ] {

        //snip... etc: check for existence of the listener

        removeEventListener( type, listeners[ type ] [ useCapture ], useCapture );

        listeners[ type ] [ useCapture ] = null;

        //clean up: if no listeners of this type exist, remove the dictionary key for the type, etc...

     }

  }

  listeners[ type ] [ useCapture ] = listener;

  super.addEventListener( type, listener, useCapture, priority, useWeakReference );

};

    


    

    

    

    

      

    • Aucune de ces options, et de faire ce qui est demandé, ce qui est pour récupérer un INCONNU écouteur d'événement à partir d'un objet EventDispatcher. Ces méthodes sont juste stocker CONNU de l'auditeur avant d'être ajouté à l'objet. Si l'auditeur n'est pas connue et stockés avant d'être ajouté à l'objet, alors il n'y a aucun moyen de le récupérer plus tard.
      • 

    • Mais ils ne vous offrons les moyens de faire de l'inconnu des écouteurs d'événement, qui est une autre façon d'aborder le problème.
      • 

    

    

    
InformationsquelleAutor geraldalewis
  4. 2

    J'ai écrit une sous-classe appelée EventCurb à cet effet, voir mon blog ici ou collez ci-dessous.

    package
{
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
/**
* ...
* @author Thomas James Thorstensson
* @version 1.0.1
*/
public class EventCurb extends EventDispatcher
{
private static var instance:EventCurb= new EventCurb();
private var objDict:Dictionary = new Dictionary(true);
private var _listener:Function;
private var objArr:Array;
private var obj:Object;
public function EventCurb() {
if( instance ) throw new Error( "Singleton and can only be accessed through Singleton.getInstance()" );
}
public static function getInstance():EventCurb {
return instance;
}
override public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
{
super.addEventListener(type, listener, useCapture, priority, useWeakReference);
}
override public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
{
super.removeEventListener(type, listener, useCapture);
}
public function addListener(o:EventDispatcher, type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
//the object as key for an array of its event types
if (objDict[o] == null)  objArr = objDict[o] = [];
for (var i:int = 0; i <  objArr.length; i++) {
if ( objArr[i].type == type)
trace ("_______object already has this listener not adding!")
return
}
obj = { type:type, listener:listener }
objArr.push(obj);
o.addEventListener(type, listener, useCapture, priority, useWeakReference);
}
public function removeListener(o:EventDispatcher, type:String, listener:Function, useCapture:Boolean = false):void {
//if the object has listeners (ie exists in dictionary)
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
for (var i:int = 0; i < tmpArr.length; i++) {
if (tmpArr[i].type == type) objArr.splice(i);
}
o.removeEventListener(type, listener, useCapture);
if (tmpArr.length == 0) {
delete objDict[o]
}
}else {
trace("_______object has no listeners");
}
}
/**
* If object has listeners, returns an Array which can be accessed
* as array[index].type,array[index].listeners
* @param   o
* @return Array
*/
public function getListeners(o:EventDispatcher):Array{
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
//forget trying to trace out the function name we use the function literal...
for (var i:int = 0; i < tmpArr.length; i++) {
trace("_______object " + o + " has event types: " + tmpArr[i].type +" with listener: " + tmpArr[i].listener);
}
return tmpArr
}else {
trace("_______object has no listeners");
return null
}
}
public function removeAllListeners(o:EventDispatcher, cap:Boolean = false):void {
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
for (var i:int = 0; i < tmpArr.length; i++) {
o.removeEventListener(tmpArr[i].type, tmpArr[i].listener, cap);
}
for (var p:int = 0; p < tmpArr.length; p++) {
objArr.splice(p);
}
if (tmpArr.length == 0) {
delete objDict[o]
}
}else {
trace("_______object has no listeners");
}
}
}
}
    InformationsquelleAutor Thomas Thorstensson
  5. 1

    Quelque chose que j'aime faire est d'utiliser une dynamique Globale de la classe et d'ajouter une référence rapide à la fonction d'écoute en ligne. C'est en supposant que vous aimez avoir la fonction d'écoute à la méthode addEventListener comme je le fais. De cette façon, vous pouvez utiliser removeEventListener à l'intérieur de la méthode addEventListener 🙂

    Essayez ceci:

    package {
import flash.display.Sprite;
import flash.events.Event;
import flash.text.TextField;
[SWF(width="750", height="400", backgroundColor="0xcdcdcd")]
public class TestProject extends Sprite
{   
public function TestProject()
{
addEventListener(Event.ADDED_TO_STAGE, Global['addStageEvent'] = function():void {
var i:uint = 0;
//How about an eventlistener inside an eventListener?
addEventListener(Event.ENTER_FRAME, Global['someEvent'] = function():void {
//Let's make some text fields
var t:TextField = new TextField();
t.text = String(i);
t.x = stage.stageWidth*Math.random();
t.y = stage.stageHeight*Math.random();
addChild(t);
i++;
trace(i);
//How many text fields to we want?
if(i >= 50) {
//Time to stop making textFields
removeEventListener(Event.ENTER_FRAME, Global['someEvent']);
//make sure we don't have any event listeners
trace("hasEventListener(Event.ENTER_FRAME) = "+hasEventListener(Event.ENTER_FRAME));    
}
});
//Get rid of the listener
removeEventListener(Event.ADDED_TO_STAGE, Global['addStageEvent']);
trace('hasEventListener(Event.ADDED_TO_STAGE) = '+hasEventListener(Event.ADDED_TO_STAGE));
});
}
}

    }

    //looky ici! C'est l'important
    dynamique de classe Mondiale {}

    Le secret, c'est la dynamique de classe Mondiale. Avec cela, vous pouvez ajouter dynamiquement des propriétés lors de l'exécution.

    InformationsquelleAutor Jonathan Dumaine
  6. 0

    La suite de ne pas aborder la question fondamentale de la suppression d'événement inconnu des auditeurs, mais si ce que vous avez besoin est de désactiver tous les événements liés à la souris, y compris les inconnus, il suffit d'utiliser:
    mouseEnabled=false sur votre cible de l'événement.

    Plus de bonnes choses ici:
    http://www.thoughtprocessinteractive.com/blog/the-power-and-genius-of-mousechildren-and-mouseenabled

    InformationsquelleAutor Daniel Szmulewicz
  8. 0
    private function callFunction(function:Function):void
{
checkObject();
obj.addEventListener(MouseEvent.CLICK,function);
}
private function checkObject():void
{
if(obj.hasEventListener(MouseEvent.CLICK))
{
//here remove that objects
}
}
    InformationsquelleAutor