Listeners and AsBroadcaster
         by senocular

In this section, briefly explain what the tutorial will explain/accomplish. If you want, you can include something "dramatic" that gets readers interested in your topic. Try to enjoy writing tutorials and follow the basic guidelines found below. Before I forget, feel free to modify this document as much as needed.

Extending What Was
Buttons are a good example to start with. The entire concept of a button revolves around user interaction, typically that of pressing. When you press a button, you expect certain results to follow, and when properly coded, they do. What determines when these events occur is the button's ability to detect or listen for the user interaction. When the pressing of the button is detected or broadcasted by the flash player, the on(press) event in that button is handled and the containing code executed. Other events buttons listen for are release, rollOver, etc., while Flash movieclips similarly listener for events such as enterFrame, mouseMove, keyDown, etc.

Prior to Flash MX, these listener objects (buttons and movieclips) were pre-defined by Flash and could not be altered, nor new ones created, by the author of the movie. MX has changed all that with the new object model. Buttons and movieclips are still pre-defined, but now you can have your very own custom objects listen for certain events like those recognized by buttons and movieclips as they occur in Flash. Of course these custom objects are not restricted to the predefined events such as keyDown or mouseMove. You have the option of making your own events with the use of AsBroadcaster (Action Script Broadcaster).

So what kinds of events, or broadcasters, are built into Flash? Well, these are

Event Broadcaster Handled by (Listeners)
 onDragOut  -  Button, MovieClip
 onDragOver  -  Button, MovieClip
 onKeyDown  Key  Button, MovieClip
 onKeyUp  Key  Button, MovieClip
 onKillFocus  -  Button, MovieClip, TextField
 onPress  -  Button, MovieClip
 onRelease  -  Button, MovieClip
 onReleaseOutside  -  Button, MovieClip
 onRollOut  -  Button, MovieClip
 onRollOver  -  Button, MovieClip
 onSetFocus  Selection  Button, MovieClip, Selection, TextField
 onData  -  MovieClip, LoadVars, XML
 onEnterFrame  -  MovieClip
 onLoad  -  MovieClip, LoadVars, Sound, XML
 onMouseDown  Mouse  MovieClip
 onMouseMove  Mouse  MovieClip
 onMouseUp  Mouse  MovieClip
 onUnload  -  MovieClip
 onResize  Stage  Stage
 onChanged  TextField  TextField
 onScroller  TextField  TextField

You'll notice that not all of the events, like onDragOut, are associated with a broadcaster object. You can consider these to be broadcasted by the Flash player itself rather than through an actionscript object within Flash. These events are restricted to being used only by whatever objects can handle them, as listed. onDragOut, for example, being only available for use with a Button or MovieClip object. The ones with broadcasters allow you to add your own listeners to these objects allowing those listeners to recognize when an event is initiated. For example, you could make a generic object in actionscipt and have it listen to the Mouse object (a broadcaster) which will then allow that object to run onMouseDown, onMouseMove, and onMouseUp code whenever the mouse is pressed, moves or is released.

There are two different ways to look at listeners and really understand how they work. The more literal sense revolves around focusing on the individual listeners themselves and how they can become “aware” and listen for events occuring in Flash. The other is based more on how listeners and AsBroadcaster works internally in Flash.

Listeners Listen
One of my first usages of listeners was getting a movieclip in MX to recognize an onKeyUp event. If an onClipEvent(keyUp) is placed on the movieclip itself, the keyUp event is recognised and my inserted code would run appropriately. Trying to define the event through instance_mc.onKeyUp = function(){...} yielded no result. It wasn't until later I realized that I had to make my movieclip a listener of the Key object so it would know when the key was pressed and would recognise to run the onKeyUp event when a key on the keyboard was released. To do that:

instance_mc.onKeyUp= function(){
// key up code

Why is a movieclip not automatically a listener of the Key object as it is as an onClipEvent? To be honest, I'm not sure and am too lazy to look it up for the purposes of this article. Its registered as a listener of the Mouse object by default (though thats not entirely true since its not really being handled by the Mouse broadcaster but the Flash player itself, but...) for example instance_mc.onMouseUp = function(){...} works, but not Key.

Nonetheless, once any object, such as my movieclip object, becomes a listener of a broadcasting object, it can then recognize events sent out by that broadcasting object and perform the appropriate actions. From the list we see Flash's broadcasting objects are


Each one of these can have listeners added to them using the addListener() method, making the passed object aware of its events. The Selection object, for example, has one event, onSetFocus which is run whenever the focus in Flash changes. When an object is added to the Selection object as a listener (and this can be any object, a generic object, a movieclip, or even a button) it then becomes aware of whenever the Selection object broadcasts that event and runs whatever onSetFocus function assigned to that object.

Example 1
So lets make an object and have it be a listener to the Mouse object. This train of thought is the first I mentioned, the “literal” way of thinking meaning we'll follow the metaphors set aside by Macromedia in understanding how listeners work. That metaphor being that of a listener. A listener is an object that listens for an event to occur and then executes a given script based on what event it was.

// make a new generic object
aBigEar = new Object();

// define a function to perform a task
Flicked = function(){
trace("Ouch, you just flicked me!");

// make aBigEar a listener for events from the Mouse object

// assign an onMouseDown event to aBigEar
// since aBigEar is a listener of the Mouse object, it will
// recognise mouse events just as a movieclip would
aBigEar.onMouseDown = Flicked;

You can throw this code right into a new movie and test it out. When you click the mouse, the output window will display “Ouch, you just flicked me!” aBigEar, once made a listener of the Mouse object, runs whatever is assigned to its onMouseDown whenever the mouse is pressed. In this case, the function Flicked is run and the contained trace message is displayed.

onMouseDown itself, to the aBigEar object, is nothing more than just an ordinary function. There's really nothing special about it despite the pretty color-coding given to it by Flash. You could call this function just as easily by saying aBigEar.onMouseDown(). The Mouse object though, has the event onMouseDown associated with it. Because of this, when the aBigEar object is set to listen to the Mouse object, it will hear when that onMouseDown event is triggered and run its own onMouseDown function. AsBroadcaster lets you define your own events, letting you call whatever function you want in your listener object(s).



SUPPORTERS:'s fast and reliable hosting provided by Media Temple.