AS3 - Escucha de eventos que solo se activa una vez

Question

Estoy buscando una forma de agregar un EventListener que se eliminará automáticamente después de la primera vez que se dispare, pero no puedo encontrar la forma de hacerlo de la manera que quiero .

me encontré con esta función (here):

public class EventUtil 
{ 
    public static function addOnceEventListener(dispatcher:IEventDispatcher,eventType:String,listener:Function):void 
    { 
     var f:Function = function(e:Event):void 
     { 
       dispatcher.removeEventListener(eventType,f); 
       listener(e); 
      } 
      dispatcher.addEventListener(eventType,f); 
    } 
} 

Pero en lugar de tener que escribir:

EventUtil.addOnceEventListener(dispatcher, eventType, listener); 

me gustaría usarlo de la forma habitual:

dispatcher.addOnceEventListener(eventType, listener); 

¿Alguien tiene una idea de cómo se podría hacer esto? ¿nordeste?
Cualquier ayuda sería muy apreciada.

---

(Sé que es Signals Robert Penner puede hacer esto, pero no puedo usarlos ya que significaría una gran cantidad de reescritura del código que no puedo pagar por mi proyecto actual)

Answer 1

me parece la manera más limpia sin necesidad de utilizar la estática o echar a perder su código con el ruido es definir una función global (en un archivo llamado removeListenerWhenFired.as) de esta manera:

package your.package 
{ 
    import flash.events.Event; 
    import flash.events.IEventDispatcher; 

    public function removeListenerWhenFired(callback:Function, useCapture:Boolean = false):Function 
    { 
     return function (event:Event):void 
     { 
      var eventDispatcher:IEventDispatcher = IEventDispatcher(event.target) 
      eventDispatcher.removeEventListener(event.type, arguments.callee, useCapture) 
      callback(event) 
     } 
    } 
} 

entonces se puede detectar eventos, así:

import your.package.removeListenerWhenFired 

// ... class definition 

    sprite.addEventListener(MouseEvent.CLICKED, 
     removeListenerWhenFired(
      function (event:MouseEvent):void { 
       ... do something 
      } 
     ) 
    ) 

Answer 2

I No lo he probado, pero podría convertir el método estático EventUtil en un método estándar y extender la clase en su objeto.

public class OnceEventDispatcher 
{ 
    public function addOnceEventListener(eventType:String,listener:Function):void 
    { 
     var f:Function = function(e:Event):void 
     { 
       this.removeEventListener(eventType,f); 
       listener(e); 
      } 
      this.addEventListener(eventType,f); 
    } 
} 

public class Example extends OnceEventDispatcher 
{ 


} 

var ex:Example = new Example(); 
ex.addOnceEventListener(type, func); 

Answer 3

functionadd.addEventListener(COMPLETE,functionremove); 

functionremove() 
{ 
    runevent(); 
    functionadd.removeEventListener(COMPLETE,functionremove); 
} 
function runevent() 
{ 
    trace('Hello'); 
}