For a while, I’ve been wondering if there was a better way of catching events from MovieClips in an object-oriented context. If you use the “onEvent” hooks in MovieClip, they store only the address of your function. The way I did it in Prove It was by (taking deep breath) creating a static method in a special MovieClip wrapper class that used the this keyword as the key in a hashed array for looking up registered instance references…
In other words, something like this:
class ClipWrapper
// Dave Seah's Magic Event Manager
static var lookup:Array;
static var ON_PRESS_EVENT = 10;
static var ON_RELEASE_EVENT = 11;
static function RegisterClip(clip:MovieClip, obj, method:Function) {
var execObj = new Object();
execObj.obj = obj;
execObj.method = method;
lookup[clip]=execObj;
}
static function DispatchEvent (clip:MovieClip, eventType:Number) {
var execObj = lookup[clip];
var obj = execObj.obj;
var method = execObj.method;
method.call(obj, eventType);
}
private var clip:MovieClip; // wrapped clip
function ClipWrapper() {
clip = _root.createEmptyMovieClip();
RegisterClip(clip,this,HandleClipEvent);
clip.onPress = function () {
ClipWrapper.DispatchEvent (this, ON_PRESS_EVENT)
}
clip.onRelease = function () {
ClipWrapper.DispatchEvent (this, ON_RELEASE_EVENT)
}
}
function HandleClipEvent(eventType:Number) {
switch (eventType) {
...
}
}
}
This works around the problems with using the MovieClip event handlers onPressEvent or what have you…they do not execute in an object-context, so none of the instance variables are available. However, when the callback is executed, the anonymous function’s this is set the movieclip that triggered the event. And since we have a static method defined as ClipWrapper.DispatchEvent(), we can call it so it can look up the object that has registered to receive events, then call the method & restore the object context.
I thought that was pretty cool, but registering and de-registering objects in the array is a bit slow when you get to 500 or so objects (the hashing slows way down). But in a ClipWrapper managing only a few clips, lookup should be relatively fast.
Other people must have figured this out, but I wasn’t finding much online. So this seemed to indicate to me that there was a far easier way of doing it that I just was missing. After reading Essential ActionScript 2.0, I realized that this was the Mouse.AddListener function. You can track MouseUp, MouseDown, and MouseMove and roll-your-own event management this way. And Listeners are completely object friendly, unlike Callbacks.
There might still be an advantage to the way I was doing it before for making use of the built-in event masking that happens when you nest movieclips, so I’m continuing to look into it.
Extending a MovieClip directly might also get away from this problem, but I don’t like writing code that requires you to establish class linkages in the Flash Library. A foible, I know.
For the current game project, I’m using Mouse.AddListener. The interactivity is pretty limited, so I don’t anticipate having to roll things together. I’m curious what kind of benchmark improvement might occur by using a native code dispatch mechanism.
