I love automating redundant tasks. One thing that bugs me when importing graphical assets to Flash's stage is having to resize the document to what I imported. I like that I can do this by going to the Document Properties and setting the document to match the content size, but if I have to do this each time I import/export content it becomes a irksome chore. I write JSFL scripts that run tasks on multiple files, having a "match contents" function would be useful to me in my case...maybe to you as well. I do not see a JSFL way to do this. (Maybe there is and I had a brain fart?). Until then, here is a script I wrote to do it in JSFL...

/*****************************************************************************************
What:	Document_to_Content_Size.jsfl
		JSFL Command for Flash (8+) that will resize the document to fit the content
		that is on the stage in the authoring environment.

Why:		Yep, this action can also be done by going to the Document Properties
		and setting "match" to "contents". However, I have not
		found a way to do this same action within JSFL script
		If you know a JSFL way to do this same action easier contact me.		

Date:		March 21, 2010
Author:	Keith Hair
Contact	khos2007@gmail.com
Web:		keith-hair.net		

INSTALL:
		If you deal with JSFL you probably know what to do, but anyway...
		Save this script with a ".jsfl" extension and put in:
		"Your Flash installation folder\en\First Run\Commands" folder
		Or just put it anywhere and double-click the file.

LEGAL STUFF:
		This script is free for whatever, just improve it or say hello! 		

NOTE:
		This is primarily for resizing the Flash
		document to fit content that is imported to the stage.
		Resizing is buggy with Component instances.

******************************************************************************************/
fl.outputPanel.clear();
runApp();
function runApp()
{
	var doc=fl.getDocumentDOM();
	var element;
	var docw=1;
	var doch=1;
	var fn=0;
	var ln=0;
	var en=0;
	var tframes;
	var layer;
	var frame;
	var ox;
	var oy;
	var left=null;
	var right=null;
	var top=null;
	var bottom=null;
	var cf=doc.getTimeline().currentFrame;
	while(ln < doc.getTimeline().layerCount)
	{
		layer=doc.getTimeline().layers[ln];
		tframes=layer.frameCount;
		fn=0;
		while(fn < tframes)
		{
			doc.getTimeline().currentFrame = fn;
			frame=layer.frames[fn];
			en=0;
			while(en < frame.elements.length)
			{
				element = frame.elements[en];
				ox=element.x;
				oy=element.y;
				if(left == null){
					left=ox;
				}
				if(right == null){
					right=ox+element.width;
				}
				if(top == null){
					top=oy;
				}
				if(bottom == null){
					bottom=oy+element.height;
				}

				left=Math.min(ox,left);
				right=Math.max(ox+element.width,right);
				top=Math.min(oy,top);
				bottom=Math.max(oy+element.height,bottom);
				en++;
			}
			fn++;
		}
		ln++;
	}
	fl.trace("CURRENT SIZE-->\t"+doc.width+" x "+doc.height);
	docw=Math.round(right-left);
	doch=Math.round(bottom-top);
	moveAllElementsBy(-left,-top);
	doc.width=docw;
	doc.height=doch;
	fl.trace("NEW SIZE-->\t\t\t"+doc.width+" x "+doc.height);
	doc.getTimeline().currentFrame=cf;
}

function moveAllElementsBy(tx,ty)
{
	doc=fl.getDocumentDOM();
	var element;
	var fn=0;
	var ln=0;
	var en=0;
	var tframes;
	var layer;
	var frame;
	var otp;
	while(ln < doc.getTimeline().layerCount)
	{
		layer=doc.getTimeline().layers[ln];
		tframes=layer.frameCount;
		fn=0;
		while(fn < tframes)
		{
			doc.getTimeline().currentFrame = fn;
			frame=layer.frames[fn];
			en=0;
			while(en < frame.elements.length)
			{
				element=frame.elements[en];
				element.x+=tx;
				element.y+=ty;
				if(element.elementType.search(/instance|text/mig) == -1){
					element.x+=element.width/2;
					element.y+=element.height/2;
				}

				en++;
			}
			fn++;
		}
		ln++;
	}

}

When an app or game is written we "expect" the user to precisely press the proper key or key combination at a time to execute programmatic actions. However, most of us have ten fingers and we use more than one finger to press more than one button on the keyboard. The expected program reaction from multiple fingered keyboard input might not occur because you have another function executing when you expect just one at a time.

Key Combinations
Imagine you are using the keyboard to play a game. The RIGHT arrow key is for moving your character right, the LEFT arrow key is for moving your character LEFT.
Ok, the action in this game is heating up, you are pressing LEFT to avoid the lasers shooting at you. You successfully dodged the lasers, now you press RIGHT to move in and attack...but in the heat of battle, your other finger is still on the LEFT button. What happens now is your character most likely gets stuck, because both movement keys are pressed telling the character to go in opposite directions!

In some cases allowing multiple key presses is how you want the app to react. For example you want the user to press both UP and RIGHT keys to move the characters in a diagonal direction. When to allow this and when not can be different among all of the control buttons. It becomes messy having to write "If" and "switch" statements to make the KeyboardEvent listeners work according to the different controls needed.

Key Sequences
If you love video games cheats or the easter eggs developers sometimes place in apps you'll remember to access them, you will usually enter in a sequence of key presses. If you entered the sequence successfully you would have access to cool game cheats or some special developer mode of an application.

KeyManager
For the above reasons I've written a KeyManager class to add key control that allows individual keys/keycombos the option to cancel out the any previous key/keycombo that are pressed down...and when key/keycombos are released, whatever key/keycombo that are still pressed will be active again. And for detecting key press sequences the KeyManager class will allow also.

This is a basic example using KeyManager. The "addKey" method is for adding key press combos and the "addKeySequence" is for obviously adding
key press sequences.

In the working flash example, you can click "singular combos" checkbox to false, to see the problem described previously about the character getting stuck when pressing RIGHT and LEFT key at the same time. When you set the checkbox back to true you will notice how each new key press overrides any others that are still down. This results in responsive execution if a user has a habit of holding down other keys while pressing new ones..

Also in the working sample above if you enter in the proper key sequence you will be rewarded with an "Easter Egg" to view the source and FLA.

Example usage:

import net.keithhair.KeyManager;

var keyManager:KeyManager;
keyManager=new KeyManager(stage);
keyManager.addKey(["right"], goRight,stopRight,"control1");
keyManager.addKey(["left"], goLeft,stopLeft,"control2");
keyManager.addKey(["up"], goUp,stopUp,"control3");
keyManager.addKey(["down"], goDown,stopDown,"control4");
keyManager.addKey(["shift","w","t"], toggleWindow);
keyManager.addKeySequence(["up","up","down","down","left","right","left","right"],openEasterEgg);

Quadrant 1 = (+,+)
Quadrant 2 = (-,+)
Quadrant 3 = (-,-)
Quadrant 4 = (-,+)

My interest in this post is about the positive or negative sign of what the Cosine, Sine, and Tangent functions return for the same angle...the angle from one Point to another Point. The sign of these 3 Math functions are different also whenever a Point is located in one of the 4 quadrants.

Quadrant 1 = +Sine,+Cosine,+Tangent
Quadrant 2 = +Sine,-Cosine,-Tangent
Quadrant 3 = -Sine,-Cosine,+Tangent
Quadrant 4 = -Sine,+Cosine,-Tangent

Personally I don't think the order or name of the quadrants are important, as long as you keep them consistent with the coordinate system. For my usage, I order my quadrants "1,2,3,4" clockwise since ActionScript's radians values go clockwise.

I feel this will become useful sometime in the future for me when dealing with angles of Points and determining their positions relative to each other.
In a future situation I might not be given X and Y information, but may only have angle data instead. Seeing the difference of signs from the Cosign, Sine, Tangent output of the angle value will be helpful clues.

So some things come back to haunt you, if they are the ghosts of my math teachers, I will surely pay attention in class this time .

	/*=========================================================
	Using "Math.atan2" to get the angle (in radians) between
	the "reddot" and "head".

	This radian is fed into the "getSign" function so
	we can see the difference of signs.
	===========================================================*/

	var radians=Math.atan2(reddot.y-head.y,reddot.x-head.x);
	var signs:Object=getSigns(radians);
	var output:String="";

	output+="Sine:"+signs.sine;
	output+="\n";
	output+="Cosine:"+signs.cosine;
	output+="\n";
	output+="Tangent:"+signs.tangent;
	output+="\n";
	output+="\n";
	output+="Radians:"+radians;

	status.text=output;

/*============================================
Returns an object indicating the sign
of the radian's Cosine, Sine and Tangent.
==============================================*/
function getSigns(rad:Number):Object
{
	var o:Object=new Object();
	if(Math.sin(rad) >= 0){
		o.sine="+";
	}else{
		o.sine="-";
	}
	if(Math.cos(rad) >= 0){
		o.cosine="+";
	}else{
		o.cosine="-";
	}
	if(Math.tan(rad) >= 0){
		o.tangent="+";
	}else{
		o.tangent="-";
	}
	return o;
}

Foam sets up the easiest of these 3 engines for an ActionScript only project...In my opinion, setting it up to use in my Flex projects takes a little more work depending on what I use it for. Seeing the end result of it is fun to watch.

Below I'm currently using my polygon editor to test Foam out in Flex.

I run into problems with point data occasionally and it's hard to find a solution for using the data, when I can only view the problem in messy code format.
This sometimes leaves me wondering if the function I'm writing is even working correctly or not.
 
The example below is a rough tool I made to visualize and edit the Array format of points I usually work with. Over time I have transformed, gutted, and replace its code for different tests I needed it for. (The insides are not pretty.)
Yep it looks like a drawing tool, just not intended for that. I've only added certain "drawing" features I needed to make it easy to visualize the data I'm working on.

The "whereAboutSegment" function will return a String this time, with more detailed info of the Point's where-a-abouts instead of just knowing if its behind a line.

 
/*-----------------------------------------------------------------
Returns a String describing where Point P is relevant to line CD:
"left","right","front" or "behind"
If Point P is a Point on line CD, an empty String is returned.
 ----------------------------------------------------------------*/
function whereAboutSegment(P:Point,C:Point,D:Point):String
{
	var F:Point;
	var G:Point;
	var s:Boolean;
	var l:Boolean;
	var r:Boolean;
	var f:Boolean;
	var a:Number=Point.distance(P,C.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	var b:Number=Point.distance(P,C.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	s = a == b;
	if (a < b) {
		f=true;
	}
	F=C.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	G=C.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	a=Point.distance(P,F.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	b=Point.distance(P,G.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	if (a < b) {
		r=true;
	}
	F=D.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	G=D.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	a=Point.distance(P,F.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI )));
	b=Point.distance(P,G.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	if (a > b) {
		l=true;
	}
	if (s && l && r) {
		return "";
	}
	if (!f && l && r) {
		return "behind";
	}
	if (f && l && r) {
		return "front";
	}
	if (l) {
		return "left";
	}
	if (r) {
		return "right";
	}
	return "";
}
 

I had a similar problem also with my scripts. I wanted to simply know if a Point was behind a Line or not...

 
/*-----------------------------------------------------------------
Returns true if Point P is behind line defined by Points C and D.
 ----------------------------------------------------------------*/
function isBehindLine(P:Point,C:Point,D:Point):Boolean
{
	var a:Number=Point.distance(P,C.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	var b:Number=Point.distance(P,C.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	return a < b;
}
 

 
 
/*---------------------------------------------------------------------------
Returns Array of intersection Points on a quadratic curve.
An empty Array is returned if no intersection is found.
 
Parameters:
A		-Start Point of a segment to make intersection.
B		-End Point of a segment to make intersection.
sp		-Start Point of curve.
cp		-Control Point of curve.
ep		-End Point of curve.
rez		-The resolution of curve tests
Note: Uses another function for testing the intersections:
 
http://keith-hair.net/blog/2008/08/04/find-intersection-point-of-two-lines-in-as3/
 
----------------------------------------------------------------------------*/
function lineToQCurve_Intersect(A:Point,B:Point,sp:Point,cp:Point,ep:Point,rez:Number=80):Array
{
	//rez less than 2 is almost "Pointless" LOL.
	var low:Number=2;
	var high:Number=99; //100 causes infinite loop.
	rez=Math.min(Math.max(Math.min(low,high),rez),high);
	var t:Number=0;
	var ft:Number=0;
	var n:Number=99/rez;
	var C:Point=new Point();
	var D:Point=new Point();
	var L:Point=new Point();
	var ip:Point;
	var a:Array=[];
	//test possible segment intersections in a loop.
	var z:int=100;
	while (z > -1)
	{
		t=z/100;
		C.x=Math.pow(1-t,2)*sp.x+2*(1-t)*t*cp.x+Math.pow(t,2)*ep.x;
		C.y=Math.pow(1-t,2)*sp.y+2*(1-t)*t*cp.y+Math.pow(t,2)*ep.y;
		D=L;//Connect start to last end point
		L=C.clone();
		if (z == 100) {
			D=ep.clone();
		}
		ip=lineIntersectLine(A,B,C,D);
		if (ip != null) {
			a.push(ip);
			if(a.length == 2){
				break;
			}
		}
		z-=n;
	}
	return a;
}
 

One thing that bothers me is that I could not figure out how to skew along the X and Y axis at the same time. When I do set "c" and "b" Matrix properties, one of the skewed axis does not skew parallel like it should. And if I concatenate separate skew Matrices, the last concatenated skew Matrix transforms correctly but not the one before it. I'm trying to avoid using nested DisplayObjects to perform the separate X and Y skews, but that looks like an option I will have to use.

 
/*---------------------------------------------------------------------------
Sets the transform property of DisplayObject with a customized Matrix.
 
display			-An ActionScript DisplayObject.
tx					-Translation x.
ty					-Translation y.
reg				-Registation point from which all transform effects orient from.
ang				-Rotation in in degrees.
scalex				-X scale percentage.
scaley				-Y scale percentage.
skew				-Skew percentage of the DisplayObjects width or height.
axis				-String indicating which axis to skew on.
 
Note:	-The "skew" argument only works one axis at a time, If anyone knows
		 how to skew on both X and Y axis at the same time accurately please help me.
 
		-The "reg" Registration point get scaled by scalex and scaley.		 
 
----------------------------------------------------------------------------*/
function setDisplayMatrix(display:DisplayObject,
						  tx:Number=0,
						  ty:Number=0,
						  reg:Point=null,
						  ang:Number=0,
						  scalex:Number=1,
						  scaley:Number=1,
						  skew:Number=0,
						  axis:String="x"):void
{
	reg=reg||new Point();
	var curM:Matrix=new Matrix();
	var skewM:Matrix=new Matrix();
	var rotM:Matrix=new Matrix();
	var scaleM:Matrix=new Matrix();
	var rp:Point;
	var r:Number=ang*Math.PI/180;
	if(axis == "y"){
		skewM.c=Math.tan(skew);
	}else{
		skewM.b=Math.tan(skew);
	}
	scaleM.scale(scalex,scaley);
	rotM.rotate(r);
	curM.concat(scaleM);
	curM.concat(skewM);
	curM.concat(rotM);
	rp=curM.transformPoint(reg);
	curM.tx=-rp.x;
	curM.ty=-rp.y;
	curM.tx+=tx;
	curM.ty+=ty;
	display.transform.matrix=curM;
}
 

Here is a diagram I made to show what kind of skew I wanted to achieve instead of only skewing one axis at a time:

 
/*---------------------------------------------------------------------------
Returns the closest Point on Line "AB" to Point "p":
 
p			-Point, the Point to constrain to the line.
A			-Point, beginning Point of Line.
B			-Point, ending Point of Line.
as_seg	-Boolean, limits return Point between endpoints of A and B.
----------------------------------------------------------------------------*/
function constrainPointToLine(p:Point,A:Point,B:Point,as_seg:Boolean=false):Point
{
    var cp:Point=new Point();
    var dx:Number;
    var dy:Number;
    var t:Number;
 
    dx = B.x - A.x;
    dy = B.y - A.y;
    if (dx == 0 && dy == 0) {
        cp.x = A.x;
        cp.y = A.y;
    }else{
        t = ((p.x - A.x) * dx + (p.y - A.y) * dy) / (dx * dx + dy * dy);
        if (as_seg){
			t = Math.min(Math.max(0,t),1);
		}
        cp.x = A.x + t * dx;
        cp.y = A.y + t * dy;
    }
    return cp;
}