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);

In the Flex framework, there is ObjectUtil.getClassInfo().properties, but I feel is more useful to just use the XML returned from the describeType method. I like using decribeType for both plain AS3 or when using the Flex framework because its accessible in both.
Since the return of describeType is XML I have more options with E4X filtering/Regular Expressions, than using getClassInfo(). With describeType I can get info on methods as well but to keep things simple I'm only talking about accessor properties in this post. Using the "listProperties" function, I am listing the properties between 3 different classes. This is a function I wrote to show how you can make your own way to use the XML of decribeType.

In the example SWF below, there are 3 classes under inspection. The Helicopter class is a custom class extending Sprite. By setting the parameters of listProperties you can list the properties of Helicopter, or all of the properties it has by being subclassed from Sprite. The other classes are a TextField and a Sprite class. Changing the options lists a different set of properties based on type of Class of properties listed and what class its properties are declared by.

 
package
{
	import flash.display.Sprite;
 
	public class Helicopter extends Sprite
	{
		private var _roll:Number=0;
		private var _pitch:Number=0;
		private var _yaw:Number=0;
 
		function Helicopter():void
		{
			super();
		}
		public function get roll():Number
		{
			return _roll;
		}
		public function set roll(v:Number):void
		{
			_roll=v;
 
		}
		public function get pitch():Number
		{
			return _pitch;
		}
		public function set pitch(v:Number):void
		{
			_pitch=v;
 
		}
		public function get yaw():Number
		{
			return _yaw;
		}
		public function set yaw(v:Number):void
		{
			_yaw=v;
 
		}
	}
}
 

 
/*============================================================
  obj						-The instance to return properties of.
  accessType				-Set to either "readwrite" or "readonly" to return only those kind of properties.
  excludeCommonWith			-Excludes all properties 'obj' has in common with the Class you give here.
  matchesRE					-If set listProperties will only return the property names that match the RegExp.
  declaredOnlyByObjClass	-If false, will not exclude properties declared by other classes than the givin 'obj'.  
 
  Returns and Array of all the properties of the instance.
 ============================================================*/
function listProperties(obj:Object, accessType:String="readwrite", excludeCommonWith:Class=null, matchesRE:RegExp=null, declaredOnlyByObjClass:Boolean=true):Array
{
	var a:XMLList;
	var b:Array=[];
	var c:*;
	var n:int;
	var doc:XML;
	var cname:String;
	matchesRE=matchesRE || new RegExp(".+");
	accessType=accessType || "readwrite";
	accessType=accessType.toLowerCase();
	if (!RegExp(/readwrite|readonly/i).test(accessType)) {
		accessType == "readwrite";
	}
	doc=flash.utils.describeType(obj);
	cname=doc.@name;
	if (declaredOnlyByObjClass) {
		a=doc.accessor.(@access == accessType && @declaredBy == cname && matchesRE["test"](@name));
	} else {
		a=doc.accessor.(@access == accessType && matchesRE["test"](@name));
	}
	if (excludeCommonWith != null) {
		c=new excludeCommonWith();
	}
	n=0;
	while (n < a.length())
	{
		if (c != null) {
			if (Object(c).hasOwnProperty(a[n].@name) == false) {
				b.push(a[n].@name);
			}
		} else {
			b.push(a[n].@name);
		}
		n++;
	}
	return b;
}
 

download fla

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.

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 an Object with the following properties:
	enter			-Intersection Point entering the circle.
	exit			-Intersection Point exiting the circle.
	inside			-Boolean indicating if the points of the line are inside the circle.
	tangent		-Boolean indicating if line intersect at one point of the circle.
	intersects		-Boolean indicating if there is an intersection of the points and the circle.
 
If both "enter" and "exit" are null, or "intersects" == false, it indicates there is no intersection.
 
This is a customization of the intersectCircleLine Javascript function found here:
 
http://www.kevlindev.com/gui/index.htm
 
----------------------------------------------------------------------------*/
function lineIntersectCircle(A : Point, B : Point, C : Point, r : Number = 1):Object {
	var result : Object = new Object ();
	result.inside = false;
	result.tangent = false;
	result.intersects = false;
	result.enter=null;
	result.exit=null;
	var a : Number = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y);
	var b : Number = 2 * ((B.x - A.x) * (A.x - C.x) +(B.y - A.y) * (A.y - C.y));
	var cc : Number = C.x * C.x + C.y * C.y + A.x * A.x + A.y * A.y - 2 * (C.x * A.x + C.y * A.y) - r * r;
	var deter : Number = b * b - 4 * a * cc;
	if (deter <= 0 ) {
		result.inside = false;
	} else {
		var e : Number = Math.sqrt (deter);
		var u1 : Number = ( - b + e ) / (2 * a );
		var u2 : Number = ( - b - e ) / (2 * a );
		if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
			if ((u1 < 0 && u2 < 0) || (u1 > 1 && u2 > 1)) {
				result.inside = false;
			} else {
				result.inside = true;
			}
		} else {
			if (0 <= u2 && u2 <= 1) {
				result.enter=Point.interpolate (A, B, 1 - u2);
			}
			if (0 <= u1 && u1 <= 1) {
				result.exit=Point.interpolate (A, B, 1 - u1);
			}
			result.intersects = true;
			if (result.exit != null && result.enter != null && result.exit.equals (result.enter)) {
				result.tangent = true;
			}
		}
	}
	return result;
}
 

//---------------------------------------------------------------
//Checks for intersection of Segment if as_seg is true.
//Checks for intersection of Line if as_seg is false.
//Return intersection of Segment AB and Segment EF as a Point
//Return null if there is no intersection
//---------------------------------------------------------------
function lineIntersectLine(A:Point,B:Point,E:Point,F:Point,as_seg:Boolean=true):Point {
    var ip:Point;
    var a1:Number;
    var a2:Number;
    var b1:Number;
    var b2:Number;
    var c1:Number;
    var c2:Number;

    a1= B.y-A.y;
    b1= A.x-B.x;
    c1= B.x*A.y - A.x*B.y;
    a2= F.y-E.y;
    b2= E.x-F.x;
    c2= F.x*E.y - E.x*F.y;

    var denom:Number=a1*b2 - a2*b1;
    if (denom == 0) {
        return null;
    }
    ip=new Point();
    ip.x=(b1*c2 - b2*c1)/denom;
    ip.y=(a2*c1 - a1*c2)/denom;

    //---------------------------------------------------
    //Do checks to see if intersection to endpoints
    //distance is longer than actual Segments.
    //Return null if it is with any.
    //---------------------------------------------------
    if(as_seg){
        if(Math.pow(ip.x - B.x, 2) + Math.pow(ip.y - B.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
        {
           return null;
        }
        if(Math.pow(ip.x - A.x, 2) + Math.pow(ip.y - A.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
        {
           return null;
        }

        if(Math.pow(ip.x - F.x, 2) + Math.pow(ip.y - F.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
        {
           return null;
        }
        if(Math.pow(ip.x - E.x, 2) + Math.pow(ip.y - E.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
        {
           return null;
        }
    }
    return ip;
}