Started looking into other possible solutions and low-and-behold, the language reference actually tells you what to do.
At the bottom of the checkPolicyFile section, Adobe mentions steps to take with redirects:

1. Examine the value of LoaderInfo.url after you have received a ProgressEvent.PROGRESS or Event.COMPLETE event, which tells you the object’s final URL.
2. Call the Security.loadPolicyFile() method with a policy file URL based on the object’s final URL.
3. Poll the value of LoaderInfo.childAllowsParent until it becomes true.

I put together some example source code below to walk you through the steps.

private var loader:Loader;
private var accessChildTimer:Timer;
private var url:String;

private function init():void
{
	accessChildTimer = new Timer( 100, 100 );
	accessChildTimer.addEventListener( TimerEvent.TIMER, onAccessChildTimer );
}

public function loadImage():void
{
	loader = new Loader();
	loader.contentLoaderInfo.addEventListener( Event.COMPLETE, onLoaderComplete );

	var context:LoaderContext = new LoaderContext();
	context.checkPolicyFile = true;

	var request:URLRequest = new URLRequest( url );
	loader.load( request, context );
}

protected function onLoaderComplete( event:Event ):void
{
	var loaderInfo:LoaderInfo = loader.contentLoaderInfo;
	if( loaderInfo.childAllowsParent )
	{
		displayImage();
	}
	else if( loaderInfo.url != this.url )
	{
		var redirectURL:String = loaderInfo.url + "crossdomain.xml"; //Might want to write a method to append a '/' if necessary.
		Security.loadPolicyFile( redirectURL );
		accessChildTimer.reset();
		accessChildTimer.start();
	}
}

protected function onAccessChildTimer( event:TimerEvent ):void
{
	var loaderInfo:LoaderInfo = loader.contentLoaderInfo;
	if( loaderInfo.childAllowsParent )
	{
		accessChildTimer.stop();
		displayImage();
	}
}

private function displayImage():void
{
	//Access BitmapData here
}

Hopefully that helps you out!

At my job, I was starting to do a lot of Facebook work and was constantly seeing posts about Graph. Instead of waiting on Adobe, I started to edit their library locally to add support for Graph. I mentioned this on the issue tracker of Adobe’s library to see if anyone would be interested, and several people responded favorably… but no one from Adobe responded at all.

At first, I was pulling in the new Graph JS SDK on our site, initializing the user with it directly, and had just made a few line changes in the library to make the same old REST calls using it instead. This was just a bridge to start working with Graph. Once I had the user initialized with it, I was able to start taking advantage of the new calls. I then started making more changes, next supporting the JS SDK’s UI methods and then the actual API. After a few months of writing and working with the library in a production environment, I decided to upload my branch of the library to GitHub.

I did this at the beginning of September. Between May and September, several people were complaining about the complete lack of support of the official Adobe library with no response at all. In fact, Jason Crist the original author of the library who handed over control to Adobe was getting frustrated with the lack of support as well and reached out to me about joining forces on the new library. But within a week of just talking about it, Adobe comes out of the blue and says that a new library with Graph support was coming. They were obviously working on it for a while, because the day after they announced that, it was uploaded. Thanks for the head’s up Adobe!

So if you’re keeping tabs, the officially supported library didn’t see an update from December 1, 2009 through September 30, 2010. That’s almost 10 months. So you’ll forgive me if I didn’t believe this new library would be supported any better. I did however like what they had done with the library, most of it that is. I decided to rewrite my library again, but this time based on the new Adobe library. I continued to maintain my branch for several reasons: support being the biggest, a few issues I was noticing with the new library, and lack of typed value objects for the returned data.

As I find issues with the core library, I update them in my branch. Most of these changes in turn get implemented into the core library. In fact, I was annoyed that the new library required an external JS file and a special way of embedding the swf, so I rewrote the JS in an ActionScript class that gets injected into the HTML at runtime, and Adobe now uses that class directly with no modification. I reached out to Adobe to see if I could become a committer on the library, they responded, but unfortunately didn’t seem too interested. So instead I continue to maintain my branch.

Long story short, if you’re using the officially supported AS3 Facebook library, you might want to check out my branch too. You might just find that your issues and suggestions get taken into account faster, if Adobe does make any updates to their library, I make those updates as soon as I notice, and you might like having typed objects for the returned data (like FacebookUser instead of just a generic object with the user’s info).

Get it here: https://github.com/yourpalmark/facebook-actionscript-api
Docs: http://yourpalmark.github.com/facebook-actionscript-api/docs/

I also maintain an AIR branch as well: https://github.com/yourpalmark/facebook-air-api
Docs: http://yourpalmark.github.com/facebook-air-api/docs/

OMGPOP is a great place to work with an amazing team of developers building a cutting-edge multiplayer gaming site.

Following are the job details.
If you feel like you fit the qualifications and want to come in and visit, email us at jobs@omgpop.com.
Make sure you mention that you found out about it here!


FRONT END DEVELOPER

Please include examples of your work when applying.


Click image to view demo

• Papervision3D 2.1.920
• Tweener 1.33.74

Here are the list of changes that needed to be made to work with the latest Papervision3D:

• The 15 degree longitude offset no longer needs to be there. Set the offset to 0.
• The default viewportHeight on GlobeView changed to match BasicView’s default of 480.
• The default cameraType value needed to change from “FREECAMERA3D” to “Free”.
• Added a default camera pitch of -30 to go along with the default yaw of 180.
• The camera reference is now cameraAsCamera3D.
• Changed the focus and zoom of the camera to match the new defaults of 10 and 40 respectively.
• The rotation values and min/max rotation values in onRenderTick needed to be adjusted.
• The camera needed to be adjusted further back in onRenderTick but not as far down.
• The mouse values needed to be adjusted in the onMouseDown.

Here are a list of new additions made to the project:

• GlobeView set to interactive to allow the markers to be selectable.
• Earth material did not need to be interactive.
• Added background to GlobeView to fix globe rotation issues introduced when interactive was set to true on the view.
• Added default markers.
• New method to add markers by latitude and longitude.
• Display of selected marker.
• Added clone and toString methods to event.
• To fix a small bug, the defaultButton in GeoGlobe.mxml has been moved to the topmost VBox instead of the internal HBox.
• The license has been changed to MIT.
• The domain digitalflipbook has been updated to yourpalmark.
• Updated the code to follow better standards.
• The html-template now uses swfobject.

I think that about covers all of the changes. I know many people have been asking for the markers to be interactive, so enjoy!

And without further ado, here’s the new source (make sure you grab the latest Papervision3D and Tweener libraries as well):
Download GeoGlobe

Once I had successfully worked out using XIFF to connect with XMPP and pass data back and forth between the server and the client, I soon realized that I wanted to associate custom data with each user in the chat rooms.
The core protocol used in XMPP to express a user’s current network availability (offline or online, etc) is Presence.
On IM, you know when your buddies come online and become unavailable, etc because you subscribe to their presence.
The user’s presence is also sent to a chat room when he/she joins the room.

The default presence data typically only incorporates information about the user’s status (away, busy, available, etc).

The issue that I soon ran into with my chat rooms, was that our site already had a large collection of users with data associated with each user (id, username, picture, etc) and I wanted to associate this data with the chat users without duplicating the data.
The best place seemed to be their presence since its already linked directly with each user. The only issue I had was figuring out how to do that.

As I soon realized, the XMPP spec is extremely extensible and well thought through and XIFF has tried to manage this extensibility in its library as well.

In XIFF, extensions can be added to any XMPPStanza that is sent to the XMPP server.
By default, there are three core XMPP stanzas, IQ, Message and Presence.
Each of these stanza classes has an addExtension() method.

What I needed to do was write a custom extension class that I could pass into the Presence’s addExtension() method.

Digging in to the code, all XIFF extensions need to extend the Extension class and implement IExtension and ISerializable.

To implement IExtension, you will need to add getNS() and getElementName() methods.

getNS() will return the custom unique namespace that you will need to create and associate with this extension.
eg: http://yourdomain.com/extensionname

getElementName() will return the base XML element name to associate with this extension.
eg: extension_name

To implement ISerializable, you will need to add serialize() and deserialize() methods.
serialize() will convert the typed extension into XML data to be passed to the server while deserialize() will do the opposite and convert the received XML data into the typed extension.
For more detailed information on this, make sure to look at some of the existing extensions in XIFF’s library.

Once the class is complete, you will need to register the extension with XIFF. This registration process informs XIFF of the particular extension so that it knows how to handle it when it is received over the network.
This can be done by calling ExtensionClassRegistry.register( CustomExtension ) anytime before you try to pass the extension over XMPP.
Most extensions provide a static enable() method with the above code in it to handle this registration process.

At this point, you can create an instance of any of the core XMPP stanzas (IQ, Message, or Presence) and an instance of your new extension and then use the addExtension() method of the core stanza to pass in your extension.

The last step is to call the send() method on your XMPP connection passing in the XMPP stanza.

To finish up my particular example, I created a custom user extension that had the user’s id, name, picture, etc and attached it to the user’s presence.
This as mentioned above could be passed with the send method on the XMPP connection and anyone subscribed to my user’s presence would receive the custom extension as well.

One thing that I wanted to do was join a chat room and have this custom data associated with the presence information of all of the existing users in the room that gets broadcast out.
It took me a little bit to realize that the Room class has a feature for this already. Like I said, XMPP has thought of everything already.
When you join a chat room, you call the Room’s join() method and the second parameter allows you to add an array of Presence extensions. Just instantiate your custom Presence extension and wrap it in an array and pass it into the join() call.

Hopefully this helps out others that got stuck on sending custom data over XMPP with XIFF.
Let me know if you have any questions or want any other XIFF/XMPP tutorials.

That’s it!
No need to figure out the unicode range of the characters you want to embed. Just use Flash’s Character Embedding panel that you’ve probably been using forever.
It should be noted that Lee’s technique referenced at the top of this post is probably still the best way to do runtime font loading.

Click image to view demo (Right-click demo to view source)

Hopefully this demo will help you as much as it helped me, although I have to say rewriting it probably helped me learn XIFF a lot more than just downloading a completely working sample, so definitely take your time with it, there’s quite a lot under the hood.

To download the source, click on the image above to view the demo and then right-click on the demo to view and download the source.
Please note that my host is not setup with a working XMPP server so the demo is not functional above, you must download it and connect it to your own XMPP server to see it fully functioning.

As the XIFF library changes, I will try and keep this demo updated.

You can download my AS3 extension here.

I’ve also added a subheading for beta language references and added Flex Gumbo to the list.

I’ll continue to try and update the post.

One small thing I’ve always found a bit handy with CSS in XHTML is the ability to type familiar names for colors rather than the hex value.

Unfortunately, Flash’s StyleSheet does not support color names at all and Flex’s StyleManager only supports the 16 basic VGA color names.

I decided to write a class that adds static properties for all of the color names defined by SVG 1.0 (The colors in SVG 1.0 include the X11 colors with the addition of gray/grey variants. X11 includes the 16 basic VGA, or HTML4, colors as well). This class also adds two static convenience methods for returning a ColorName object by passing in the color name or hexadecimal color value.

While this class does not extend the CSS parsing capabilities of Flash, it could be used by an advanced StyleSheet class that overwrites the parseCSS method using this class as a lookup.
This class could also be extended to add (or overwrite) color values specific to a project you are working on. By setting up static properties for a project color set, the project team could be assured that the colors being used are consistent between team members.

Description:
The ColorName class defines the names and hexadecimal values of the colors defined in SVG 1.0.

Documentation:
ColorName Class Documentation

Download ColorName Class