Benutzerdefinierter Ereignisspeicherort

Question

Ich habe schon lange nach benutzerdefinierten Ereignissen (Listenern) gesucht, aber nie eine erfolgreich erstellt. Es gibt so viele verschiedene Methoden, die die Event-Klasse erweitern, aber auch die EventDispatcher-Klasse erweitern, sehr verwirrend! Ich möchte mich damit ein für alle Mal abfinden und die entsprechende Technik erlernen.

package{ 

import flash.events.Event; 
public class CustomEvent extends Event{ 

public static const TEST:String = 'test'; //what exac is the purpose of the value in the string? 
public var data:Object; 

public function CustomEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, data:Object = null):void 
{ 
this.data = data; 
super(); 
} 
} 
} 

Soweit ich eine benutzerdefinierte Klasse wissen, wo Sie die Anforderungen für den Fall festgelegt versandt werden muss gemacht werden:

package 
{ 
    import flash.display.MovieClip; 

    public class TestClass extends MovieClip 
    { 

     public function TestClass():void { 


      if (ConditionForHoldToComplete == true) { 

       dispatchEvent(new Event(CustomEvent.TEST)); 
      } 

     } 

    } 

} 

Ich bin nicht sicher, ob dies richtig ist, aber es sollte etwas in dieser Richtung sein.

Jetzt was ich will, ist so etwas wie ein mousevent, das auf ein Ziel angewendet werden kann und keine bestimmte Klasse erfordert.

Es wäre so etwas wie dies funktioniert:

package com.op_pad._events{ 
import flash.events.MouseEvent; 
import flash.utils.Timer; 
import flash.events.TimerEvent; 
import flash.events.EventDispatcher; 
import flash.events.Event; 

public class HoldEvent extends Event 
    { 
      public static const HOLD_COMPLETE:String = "hold completed"; 
      var timer:Timer; 

      public function SpriteEvent(type:String, bubbles:Boolean=true, cancelable:Boolean=false) 
      { 
       super(type, bubbles, cancelable); 

       timer = new Timer(1000, 1); 
       //somehow find the target where is event is placed upon -> target.addEventlistener 
       target.addEventListener(MouseEvent.MOUSE_DOWN, startTimer); 
       target.addEventListener(MouseEvent.MOUSE_UP, stopTimer); 
      } 

      public override function clone():Event 
      { 
       return new SpriteEvent(type, bubbles, cancelable); 
      } 
      public override function toString():String 
      { 
       return formatToString("MovieEvent", "type", "bubbles", "cancelable", "eventPhase"); 
      } 



      ////////////////////////////////// 
      ///// c o n d i t i o n s ///// 
      ////////////////////////////////// 

      private function startTimer(e:MouseEvent):void 
      { 
       timer.start(); 
       timer.addEventListener(TimerEvent.TIMER_COMPLETE, complete); 
      } 

      private function stopTimer(e:MouseEvent):void 
      { 
       timer.stop() 
      } 

      public function complete(e:TimerEvent):void { 

       dispatchEvent(new HoldEvent(HoldEvent.HOLD_COMPLETE)); 
      } 
    } 

}

offensichtlich Das wird nicht funktionieren, aber sollten Sie eine Vorstellung davon, was ich erreichen will. Dies sollte möglich sein, da mouseevent auf alles angewendet werden kann. Das Hauptproblem ist, dass ich nicht weiß, wo ich die Anforderungen für das auszuführende Ereignis einstellen soll, um es auf Movieclips und Sprites anwenden zu können.

Answer 1

Ich benutze nur Räuber Penners Signale. Sehr einfach zu bedienen.

http://github.com/robertpenner/as3-signals

Answer 2

Sie tatsächlich ist fast da, nur für den letzten Teil, wäre dies nicht mehr von einem OOP bezogenes Problem sein als stricly einer Verwirrung über die Art und Weise benutzerdefinierte Ereignisse zu verwenden?

Normalerweise sind Ereignisse in AS3 Wertobjekte, deren alleinige Verantwortung darin besteht, Informationen vom Ereignisverteiler zu den Listenern zu transportieren. Der Dispatcher löst das Ereignis jedes Mal aus, wenn ein definierter Impuls erreicht wird, und die Zuhörer reagieren möglicherweise oder nicht, wenn dies geschieht.

Im obigen Beispiel, ich denke, es liegt am Hörer, einen Timer zu starten und so weiter, wenn ein Mouse-Down erkannt wurde. In einem komplexeren Kontext könnte das Ereignis unabhängig mehr als einen Listener auslösen, der separate Aufgaben ausführt, die weder der Dispatcher noch das Event selbst kümmern müssen. Deshalb ist es wahrscheinlich sinnvoll, den Dispatcher oder das Ereignis selbst nicht durch irgendeine andere Logik zu ändern.

Für Ihr Beispiel könnten Sie vielleicht einen Handler erstellen, der überprüft, ob die Maus gedrückt wurde?

Das Folgende ist nur Pseudo-Code, und es gibt offensichtlich Tonnen anderer Wege zum gleichen Ergebnis zu erhalten:

public class MouseDownHandler 
{ 
    // ... 

    public function(target:Sprite) { 
     this.target = target; 
     start(); 
    } 

    public function start():void{ 
     // Listen for the target's mouseUp event 
    } 

    public function dispose():void{ 
     // Stop listeners and eventually the timer 
    } 

    private function onMouseDown(e:MouseEvent):void{ 
     // Start timer + listening for the stage's mouse up event (target.stage) 
    } 

    private function onMouseUp(e:Event):void{ 
     // Cancel timer 
    } 

    private function onTimerComplete(e:TimerEvent):void { 
     dispatchEvent(new HoldEvent(HoldEvent.HOLD_COMPLETE)); 
    } 
} 

, die beispielsweise auf diese Weise wiederverwendet werden könnten:

var mc:MovieClip = new MovieClip(); ... 
var mouseHandler:MouseDownHandler = new MouseDownHandler(mc); 
mouseHandler.addEventListener(HoldEvent.HOLD_COMPLETE, onMcHoldComplete); 

...oder so:

public class TestMovieClip extends MovieClip 
{ 
    private var mouseHandler:MouseDownHandler; 

    public function TestMovieClip() { 
     mouseHandler = new MouseDownHandler(this); 
     mouseHandler.addEventListener(HoldEvent.HOLD_COMPLETE, onMouseHoldComplete); 
    } 

    private function onMouseHoldComplete(e:HoldEvent):void { 
     // Do something 
    } 
}