Category — Code & Samples

Howdy loyal readers:

I've gone ahead and posted on Almer/Blank Labs the slides and sample source files from my talk @ FITC SF, 'Getting Started with OSMF', which I'll be giving tomorrow afternoon @ 2:30 in Conference Room 1.

I thought it'd be fun to get this stuff posted in advance of the talk so attendees can follow along if they want.

I will not be recording the session -- it is, however, very similar to the session I recorded at FITC Toronto, in April, and which remains posted here, on Almer/Blank Labs.

Share and enjoy!

-r

I've finally started work on my OSMF lab for MAX, 'Designing Custom Video Players with OSMF' (you can browse the catalog of talks and presentations and then you can register here).

And, as part of that, I updated the sample OSMF code for Flash, that I had written in April for OSMF 0.95, to work with OSMF 1.0.

You can read about the minor changes, and download the current source, here, at Almer/Blank Labs.

Share and enjoy!

-r

UPDATE 2009-04-29: I've removed the files linked from this post, as they are now available through Almer/Blank Labs, including the video capture of the talk, as well as the slides and source files, here at this link.

I have a few free moments here at FITC Toronto, and I wanted to post the slides and files (20 MB) from the talk I just completed, 'Standardize Your Flash With Adobe Open Source Media Framework'.

Download the Files (20MB)

As I said during the talk, these files were built with the Sprint 10 (v0.9) version of OSMF, and since I've been in Toronto, Sprint 11 (v0.95) has come out and I haven't had time to test these files yet to see if they still work.

I'll definitely be updating all of my samples as we approach the 1.0 release of OSMF, so stay tuned.

Until then, share and enjoy!

-r

I'm continuing work on my FITC Toronto talk, 'Standardize Your Flash with Adobe OSMF', and the files to accompany it.

OSMF certainly has features and functionality for hard-core developers to build powerful media-rich experiences. But OSMF also makes basic media player code really easy for those users of Flash who might not consider themselves developers, but who still are comfortable coding on the timeline.

One of the issues with the still nascent, but growing at an impressive rate OSMF documentation, is that almost all the sample code is for users of Flex Builder / Flash Builder -- and all of the sample code for Flash assumes use of external class files.

But using OSMF does not require coding in external class files. So, to illustrate that point, I've gone ahead and modified the simplest possible OSMF video player from Adobe's documentation to code that works on the timeline. Which I'm posting here.

So this is code (OSMF Sprint 10 v0.93) you can paste onto any timeline that will play video with OSMF.

Want to make it stream the video instead of playing it progressively? Point it to an RTMP URL instead, and it will automatically play.

import org.osmf.containers.MediaContainer;
import org.osmf.elements.VideoElement;
import org.osmf.media.MediaPlayer;
import org.osmf.media.URLResource;
// Create the container class that displays the media.
var container:MediaContainer = new MediaContainer();
//add the MediaContainer instance to the stage
addChild(container);
// Create the resource to play and point it to the FLV
var resource:URLResource=new URLResource("my.flv");
// Create the MediaElement
var videoElement:VideoElement=new VideoElement(resource);
//add the VideoElement to our container class
container.addMediaElement(videoElement);
//create the MediaPlayer instance
var mediaPlayer:MediaPlayer = new MediaPlayer();
// Set the MediaElement on a MediaPlayer.
//Because autoPlay defaults to true, playback begins immediately.
mediaPlayer.media=videoElement;

Share and enjoy!

-r

I'm writing some new sample files for OSMF in preparation for my presentation, 'Standardize Your Flash with Adobe OSMF,' which I'll be giving on April 27th at FITC Toronto.

Last time I checked (February), OSMF was in Sprint 9 (and I updated my sample files at that time, posted here). Now, it's in Sprint 10, specifically version 0.93. And Adobe appears to have done a lot to lock down the API, which is definitely an exciting and positive development.

But, of course, there are some significant changes since the Sprint 9 OSMF framework -- so even the files I posted just two months ago are no longer valid. So, since I wrote it as one of the sample files for my talk, I figured I would post the code to run dynamic streaming with OSMF v0.93.

Here is a Flash CS4 document class, assuming you already have your OSMF SWC in your library path.

package
{
    import flash.display.Sprite; 
 
	import org.osmf.media.MediaPlayer;
	import org.osmf.containers.MediaContainer;
	import org.osmf.media.URLResource;
	import org.osmf.net.NetLoader;
	import org.osmf.elements.VideoElement;
	import org.osmf.utils.URL;
	import org.osmf.net.DynamicStreamingResource ;
	import org.osmf.net.DynamicStreamingItem ;
 
    public class MyPlayer extends Sprite
    { 
 
		private const RTMP_URL : String = "rtmp://myhost" ;
 
        public function MyPlayer()
        {
			player = new MediaPlayer ( ) ;
			container = new MediaContainer ( ) ;
			addChild ( container ) ;
			//set the player to play videos only once by default
			player.autoRewind=false;
			var resource : DynamicStreamingResource = new DynamicStreamingResource ( RTMP_URL ) ;
			var vector : Vector.<DynamicStreamingItem> = new Vector.<DynamicStreamingItem> ( 3 ) ;
			vector [ 0 ] = new DynamicStreamingItem ( "myMovie_high" , 1500 ) ;
			vector [ 1 ] = new DynamicStreamingItem ( "myMovie_low" , 400 ) ;
			vector [ 2 ] = new DynamicStreamingItem ( "myMovie_medium" , 600 ) ;
			resource.streamItems = vector ;
			videoElement = new VideoElement( resource ) ;
			player.media = videoElement ;
			container.addMediaElement ( videoElement ) ;
        } 
 
		private var player:MediaPlayer;
		private var container:MediaContainer;
		private var videoElement : VideoElement ;
 
    }
}

Share and enjoy!

-r

While I've been away from the blog in the past several weeks, it seems that there have been two iterations of the Open Source Media Framework -- the last course I wrote was in OSMF7 and now we're at 9.

And, of course, between these two versions, the sample code in my courses posted at Adobe has become unusable.

After getting a few email requests from developers, I decided tonight to sit down and update the files for the first course -- the course in building a progressive video player in OSMF.

So, if you would like, you can get that update here.

The primary difference is that basically EVERY EVENT has changed names and types. So I had to hunt them down through the documentation, one at a time -- which I did. And also, they changed the name of the media player instance -- again -- this time, to 'media' (nee 'player', nee 'element').

Please note that I didn't really update the comments to reflect the changes to the event names and locations.

And if you're all very, very, very nice, I might consider updating the files for the Dynamic Multibitrate Streaming Player also

Share and enjoy!

-r

My new online video course on Dynamic Multi-bitrate Streaming with Adobe Open Source Media Framework (OSMF) has just gone live on Adobe Developer Connection.

It's 35 minutes across five lessons and takes you through the process of converting the progressive OSMF video player (which we create in the first installment of this course on Building Progressive Video Players with Adobe OSMF, into a dynamic multi-bitrate streaming player. Multi-bitrate streaming occurs when you program your Flash to deliver the highest quality video a viewer can see (dependent on their bandwidth). *Dynamic* multi-bitrate streaming is similar, with the additional feature of having your player constantly meters the bandwidth throughout viewing, to adjust the playback between multiple videos seamlessly, as the viewer's bandwidth may fluctuate.

Please note: that the first course on progressive video players was built with OSMF Sprint 5. The second course on streaming with OSMF was built with OSMF Sprint 7. I spend the first lesson of the new course updating the progressive player to work with Sprint 7, and I wrote a few notes about the major differences between OSMF 0.5 and 0.7 in a post on this blog last month. Also note that, by the time the course was published by Adobe, OSMF had already moved forward to Spring 8.

When I wrote the first course on building a progressive video player with OSMF, I was struck by two things:
1) OSMF is clean -- really clean -- and it just works well in ways that the AS3 video API does not -- for instance, with OSMF setting volume is a matter of talking to the volume property of the MediaPlayer
2) OSMF felt like a bit of overkill -- you need a lot of imports and classes (a MediaPlayer, a MediaElement, a NetLoader and a URLResource) just to build the simplest of progressive video players -- that would be simple enough, requiring seven lines of code with raw AS3 if you knew it

But, I had a hunch that #2 above was due to the fact that I was using approximately 0.05% of this powerful framework -- like trying to use a nuclear bomb when a shovel would do just fine.

Well, when I started learning how to write the code to build dynamic multi-bitrate streaming player, I quickly learned that my hunch was right. The benefits of OSMF really kick in once you do anything beyond the most basic video player.

In the case of streaming, to convert your progressive OSMF video player to a streaming OSMF video player, all you do is change the URL! Seriously, that's it. OSMF is smart enough to know that when you try to load a video from an RTMP server, you're trying to stream -- and it takes care of the rest.

That was pretty neat. But the benefits really kicked in when I beefed my regular streaming OSMF video player to one that supports dynamic multi-bitrate streaming. All it took was just a few extra lines of code to turn my regular video player into one that supports dynamic multi-bitrate streaming. If you want to learn those lines of code, I'd recommend checking out the course.

As I say, I'm still just barely cracking the surface of OSMF, and I'm really looking forward to digging deeper into its support for layouts, playlists and monetization. But, even with this second course, the massive time, workflow and standardization features of OSMF are already revealing themselves.

Share and enjoy!

-r

I've started work on the next installment of my training on the Adobe Open Source Media Framework (OSMF) (following my course on building a progressive video player with OSMF, published last month). And in the roughly 6 weeks since I built the code for the last course (using OSMF 0.5), we've seen two revs of the OSMF codebase, which is now in rev 7.

The framework is definitely more solid now, but, since it's still 'beta', they continue to shift things under the hood. [Read more →]

Download the Flash CS3/AS3/FP9 Source Files for this post

I've *finally* completed and posted a version of my ActionScript 3 Events workshop to the Rich Media Institute Online. I wrote the first full draft of this course almost a year ago, and I first taught it live in Los Angeles in May -- and now I've finally completed a version for online entitled, Unlocking ActionScript 3 Fluency: Events and the Broadcaster (see below for an extended excerpt of that course).

I gave this name to the course because I believe (and argue in the course) that events really are the glue that bind everything together, and understanding events is vital to achieving fluency in ActionScript 3. Understanding how to reduce the potential for errors in your code makes you a better coder; understanding how to work with and around events makes you a fluent coder.

Stated another way: everything in Flash is an object. There are two ways to make your objects communicate:

1. Direct references: which even your grandmother knows not to use if possible, since direct references create less maintainable, less reusable, and more spaghetti-ish code.
2. Events: which are dispatched and heard, and are like butter to work with

So, since objects need to communicate to do anything cool or complex, and since events are really the only clean way to have objects communicate (until you get into advanced stuff, like frameworks), well it looks like you need to understand events if you want to do anything fun, cool or sexy!

Fortunately, events in AS3 are not that hard to work with -- in fact, they are incredibly consistent and pretty darn easy. They do have some pretty key limitations, but there are several ways around them, and my course teaches a CustomEvent and a CustomEvent Broadcaster as two such solutions.

But before we get that far, there is one very most important aspect of working with events in ActionScript 3, a concept that many users of Flash do not understand when walking into my course. This concept of Display List Event Flow can be stated in two simple bullets.

Events in Flash:

• are objects
• that can travel

Unlike in real life, where an 'event' is likely not tangible (try touching a party), events in Flash are as real and tangible as anything else, such as a MovieClip. Events have properties and methods, and they exist and occupy memory -- just like any other type of object. And these events have a lifespan -- they are born, they travel (or 'flow') and they die.

Because Flash is an inherently visual platform, it is not surprising that the native event flow in Flash is inherently tied to the Display List -- the tree formed by the relationships of the display objects on our stage -- which can change each frame (since the MovieClip that's on my stage on this frame, might not be there on the next frame). To help you visualize what we're talking about when we say 'display list', here is a simple example display list:

Many events in AS3 (especially MouseEvents and KeyboardEvents, as well as any bubbling events of our own that we might dispatch in our movies) travel around the display list, in three phases:

1. the capture phase: the event is heard down from the stage to the 'target' or source of the event
2. the target phase: the event is heard on the target itself
3. the bubbling phase: the event is heard back up the display list, from the target to the stage

So, looking back at our sample display list, let's say the user clicks on sub1a, whose full path is: stage.mc1.mc1_a.sub1a. In that case, the event (in our case, a MouseEvent) would be created and dispatched first on the stage, and then down to the target (or source, in our case, sub1a) of the event, in the capture phase.

The event (again, in our case, a MouseEvent) is heard on the target (again, in our case, sub1a), in the target phase.

And finally, the event will be dispatched up the display list, from the target, to the stage, in the bubbling phase.

So, the full flow -- the complete lifespan of an event in the display list -- looks something like this:

So, to be clear, in this very, very simple example of the user clicking on sub1a, that MouseEvent can be heard in four separate locations, at seven separate occasions (3 in capture phase, 1 in target phase, and three again in the bubbles phase).

Remember! The display list event flow not only tells us which parts of the display list will hear an event, but also which parts CAN NOT hear events (this limitation gets to why it can be so difficult, with the native AS3 event flow, to have different objects hear events from different parts of your movies).

By default, when you write addEventListener in AS3, you will listen for events in the target and bubbles phases. If you use the 'useCapture' property of addEventListener, you can listen for events in the capture phase instead, as in:

addEventListener ( MouseEvent.CLICK , _onClick , true ) ;

Why would you ever want to hear an event in the capture phase? Well, honestly, it's rare, but we had to use it today at work to suppress keyboard input from being heard in parts of our movie in certain specific instances, so there are times when it can come in handy. But it's still useful to know about, because 'capture' makes 'bubbling' make a whole lot more sense!

I've prepared two Flash CS3/AS3/FP9 samples (including source) that hopefully help demonstrate the concept. The first is intended to provide visual indication of the actual event flow, including the phases, and which branches of the display list can hear an event. The second provides a more accurate estimation of the timing of the event flow -- which lasts milliseconds -- by tracing messages to a textarea. I'm embedding the visual one at 50% so you can get a sense of it here.

Visual Display List Event Flow Tracer

Preview from R's AS3 Events Course

Share and enjoy!

-r

Source files for this posting>>

A few nights ago, as I was at my folks' house in New Jersey, and had a touch of the jet lag. So, checking Facebook, and one of my friends, Bram, had posted a challenge to his wall. He was looking for a Flash guy to create a Flash app to:

• load any Flash video from your hard-drive
• select the frame/location
• drag-resize/reposition a marquee selection
• save a JPG of the selected area to your hard-drive

I realized that this was possible in Flash Player 10 (no AIR required) because of the changes to the FileReference API (summarized by Lee Brimelow here), and that I actually already had all the code for it across several separate project files for courses I teach at the Rich Media Institute. The one limitation is that, with Flash video, you can only seek to keyframes (so, with this video snapshot tool, you can pause it at any time, but if you want to seek, you can only seek to keyframes), but Bram signed off on that proviso and so, in about two hours, I combined all the code snippets to make it work and got it to Bram before I went to bed.

The next day, I realized it would actually be more useful if I encapsulated all of the code that handles the snapshot to a single, reusable class file / library symbol. So that's what I did. And I'm attaching the results here. Full disclaimer: This was just a goof and is not fool-proof code, but does demonstrate the concept nicely.

So, what's included:

• snapper.fla which includes the SnapshotRectangle MovieClip (on top of a sample image of my gorgeous golden, Lelia)
• com.rblank.snapper.SnapshotRectangle.as, to which the SnapshotRectangle MovieClip symbol is linked, and which contains all of the custom code I've written for this sample
• ActionScript 3 Core Libraries, created by the uber-scripters at Adobe, which I use here for JPEGEncoding (not inherent to the Flash Player 10 AS3 API). I'm including it in the download so it will work 'out-of-the-box' but you should of course download and use the most recent from their repository site

As you can see in the sample file (embedded and attached) the SnapshotRectangle has a:

• Textfield instance, tf_dims, to display dimensions of the image that will be created
• A MovieClip instance, named bg, that visually indicates the size of the image that will be created
• A MovieClip instance, named nub, that will be used to resize the snapshot area
• A NumericStepper instance, named ns_quality, that will be used to determine JPG quality
• A Button instance, named btn_snap, that will be the trigger for saving the JPG

The code is fully commented, so check it out. But essentially, you:

1. Create a BitmapData object and draw into it
2. Encode the BitmapData into a ByteArray, using the JPGEncoder class
3. Save the ByteArray (representing a JPG) to the user's computer, using the FileReference class

That's the pseudo-code. The actionscript is:

//create a BitmapData instance, sized to match the width and height of the bg MovieClip instance
_bitmapData =new BitmapData ( bg.width , bg.height );
//draw the entire stage into the BitmapData instance, clipping by the _matrix
_bitmapData.draw( stage );
//create a new JPGEncoder instance (an AS3CoreLib class)
//and pass in the current value of the ns_quality NumericStepper instance as the JPG quality
_jpg= new JPGEncoder(ns_quality.value);
//encode the _bitmapData into JPG data, stored in the _byteArray
_byteArray=_jpg.encode(_bitmapData);
//create the new FileReference instance through which to save the JPG data to the user's machine
_fileRef_save = new FileReference ( );
//save the _byteArray to the users computer, with a default name of 'RBlankSnapshot.jpg',
//which the user will have a chance to rename before saving
_fileRef_save.save( _byteArray , "RBlankSnapshot.jpg" );

You'll note that in the actual code, since this single MovieClip encapsulates all the drawing logic (meaning, it has no idea which specific display objects will actually be visible in the rendered image), so you have to hide this MovieClip while drawing into the bitmap data (otherwise, this SnapshotRectangle GUI will be in the JPG).

Share and enjoy!

-r

Source files for this posting>>

addFrameScript, both powerful and undocumented, is an ActionScript 3 method supported by instances of the MovieClip class. It is inherently part of the way that Flash creates SWFs, which means that, while it is undocumented, it will likely be with us for some time.

To start, let's define the pain:

1. When coding in Flash, it is generally optimal to remove as much code as possible from your timelines (if you don't know that yet, then just trust me)
2. AS3 symbol linkage and the document class make it very easy to move *a lot* (but not all) of your code to external files
3. But, using these techniques, it is not really possible to remove *all* code from your timelines, since code in class files is effectively on frame 1 of your linked timeline. For example, let's say you need to place a 'stop()' action on frame 10. How do you do that in a class file?

So, the solution -- the method you need to know in order to move *ALL* code from your FLAs to external class files -- is addFrameScript(). It's a really simple method.

someMovieClip.addFrameScript(aFrameNumber,aFunctionToRun);

In this example, we are saying:

• When the MovieClip with the instance name someMovieClip
• hits frame number aFrameNumber
• run the function named aFunctionToRun

And voila! It's that simple. Two notes:

• Frame numbers in addFrameScript are 0-based, if you want to put a function on frame 1, you'd call addFrameScript with the number 0.
• The function you call (aFunctionToRun in the above example) is treated just like a regular function -- not like a callback function on an event. That means the function expects no arguments.

Take the following example (in the folder named 'byFrameNumber' in the attached ZIP), in which we have a main timeline that contains a MovieClip instance with the instance name of mc. Let's assume we want to tell mc to stop on its final frame. Here's the code.

On the timeline

//tell mc to run stopMe when it hits its final frame (the measure is 0-based)
mc.addFrameScript ( mc.totalFrames - 1 , stopMe ) ;
 
//stopMe is called on the final frame of mc, but it is not a 'callback'
function stopMe ( )
{
	//tell mc to stop ( ) ;
	mc.stop ( ) ;
}

In a class file

package
{
	import flash.display.MovieClip;
	public class AddFrameScriptSample extends MovieClip
	{
		public function AddFrameScriptSample()
		{
			//tell mc to run stopMe when it hits its final frame (the measure is 0-based)
			mc.addFrameScript(mc.totalFrames-1,stopMe);
		}
		//stopMe is called on the final frame of mc, but it is not a 'callback'
		//it MUST be public
		public function stopMe():void
		{
			//tell mc to stop
			mc.stop();
		}
	}
}

After looking through this code and learning addFrameScript, you might ask 'is there any way to work with frame labels rather than frame numbers'? Why yes, Virginia, there is. To do that, we need to work with the currentLabels property of the MovieClip class.

currentLabels is an array of 'FrameLabel' objects -- so, for each frame on your MovieClip's timeline, there will be a FrameLabel object created and inserted into the currentLabels array.

A FrameLabel consists of a name (the string identifier of the frame label) and a frame (the 1-based number of the frame that contains the label stored in name). NOTE: that the frame property is 1-based, while addFrameScript expects 0-based frame numbers. So you need to account for that.

So, in the sample code contained in the folder named 'byFrameLabel' in the attached ZIP, we have a MovieClip on our stage, with an instance name of mc, and it contains a multi-frame tween, with four labeled frames. This code tells that mc MovieClip to stop on any frame that has a label, and to resume when the stage is clicked.

On the timeline

//create an array of all frame labels in the mc MovieClip
var aLabels = mc.currentLabels;
//for each label in the array
for each (var n in aLabels) {
	//trace out the name and frame number of the frame label
	trace( n.name + " @ " + n.frame );
	//add a call to stopMe() on each frame with a label
	mc.addFrameScript( n.frame - 1 , stopMe );
}
//start listening for the mouseDown event anywhere in our movie, calling onDown as the callback
stage.addEventListener( MouseEvent.MOUSE_DOWN , onDown );
 
//called as callback from mouseDown event on stage
function onDown( evt ) {
	//tell the mc MovieClip to play
	mc.play( );
}
//called by assignment with addFrameScript, by every frame of the mc MovieClip with a label
function stopMe( ) {
	//tell the mc MovieClip to stop
	mc.stop( );
	//trace what frame the mc MovieClip is on
	trace( "stopping at frame " + mc.currentFrame );
}

In a class file

package {
	import flash.display.MovieClip;
	import flash.events.MouseEvent;
	public class CurrentLabels extends MovieClip {
		//--------------------------------------
		//  CONSTRUCTOR
		//--------------------------------------
		public function CurrentLabels(){
			//create an array of all frame labels in the mc MovieClip
			var aLabels = mc.currentLabels;
			//for each label in the array
			for each (var n in aLabels) {
				//trace out the name and frame number of the frame label
				trace( n.name + " @ " + n.frame );
				//add a call to stopMe() on each frame with a label
				mc.addFrameScript( n.frame - 1 , stopMe );
			}
			//start listening for the mouseDown event anywhere in our movie, calling onDown as the callback
			stage.addEventListener( MouseEvent.MOUSE_DOWN , onDown );
		}
 
		//--------------------------------------
		//  PUBLIC METHODS
		//--------------------------------------
		//called by assignment with addFrameScript, by every frame of the mc MovieClip with a label
		public function stopMe ( ) : void
		{
			//tell the mc MovieClip to stop
			mc.stop ( ) ;
			//trace what frame the mc MovieClip is on
			trace ( "stopping at frame " + mc.currentFrame ) ;
		}
 
		//--------------------------------------
		//  EVENT HANDLERS
		//--------------------------------------
		//called as callback from mouseDown event on stage
		private function onDown ( evt : MouseEvent ) : void
		{
			//tell the mc MovieClip to play
			mc.play ( ) ;
		}
	}
}

Share and enjoy!

The ADDED_TO_STAGE event is a really handy one in AS3 -- it tells you when a display object has been added to the display list.

But I'd been wondering if there were a way to put a single ADDED_TO_STAGE event listener on the stage, to know when anything was added to the display list. My first attempt did not work -- but then I tried listening during the capture phase. And VOILA! It works.

Note the 'true' argument (the 3rd one) in addEventListener -- that makes the listener listen during the capture phase. I'm not sure why this event is not hearable in the bubble phase (I'm sure there's a very good, very technical reason), but there you have it.

Here's the logic:

stage.addEventListener ( Event.ADDED_TO_STAGE , onAddedToStage , true ) ;
function onAddedToStage ( evt )
{
	trace ( "onAddedToStage, evt: " + evt.target ) ;
}
addChild ( new MovieClip ( ) ) ;
 

Share and enjoy!

Yesterday afternoon I had the privilege of addressing a crowd of over 100 at MAX. Apparently, the slides and source code that accompany the talk were not placed on the attendee extranet at MAX. So, per request of some of the attendees, I am posting the files here. (If you were one of the people who attended, thank you very much for turning out.)

Download the Presentation Files

Included are:

• All code files (62 flas, and associated AS files)
• Slides used during presentation
• Extended slides for home reference

As you can see, the subject was 'Practical ActionScript 3', which is a one-hour version of a day-long (8-hour) curriculum I have created, and teach through the Rich Media Institute.

I will be teaching the full-day version of this workshop on October 24th in Toronto and November 7th in Los Angeles. A 3-hour online version is also available through the RMI (that hasn't yet been updated for Flash Player 10, as the live workshop has).

I'd also like to take this opportunity to note that I will be teaching a full-day version of my new AS3 workshop, 'Working With and Extending Events in ActionScript 3 (on October 25th in Toronto and November 8th in Los Angeles). I know 'Events' isn't often treated as it's own subject, worthy of an entire day-long course, but in my experience this is an incredibly useful subject -- events are really the key to functional fluency in AS3 and once you understand them (which really isn't *that* difficult) you can basically do anything you want in Flash. It's designed to accompany Practical AS3 (which is why I'm teaching it the immediately following day in both Toronto and LA), and I would really strongly suggest you consider enrolling.

UPDATE
So turns out Adobe captured the whole talk and posted it on Adobe TV. Share and enjoy!