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

-- Keith H --

I've seen lots of really great knobs, dials, and gauge components. The intended way a person would build their app to use one would most likely be varied . That makes each of these kinds of controls  special because its difficult to make a control that fits a very broad range of functionality/look-n-feel, and probably why I have yet to see "one knob to rule them all".   Sliders, and Buttons are pretty straight forward, but not the "Knob" type of control.

Knobs can be just like a glass of tea. Some like a twist of lemon in it, or twist of lime etc. Just like others who have made their own controls tailor made to their needs, I have done with my knob.  The good thing about that is there's always more than one person who share the same preference on how a knob should function.  I've made many custom knobs that were built for small and simple duties. I'd like to make a knob to share here that is more reusable and cover wider ranges of functionality than the older ones I've built.  The knob displayed here is configurable but not skinnable, I've chosen to draw my knob dynamically with ActionScript's drawing API.  I hope to release this one after fixing some problems in my spare time.

View demo

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

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.

If you played the first installment of Half-Life 2, you may remember the NPC characters frequently shouting "Follow Freeman".
As the NPC characters stood around idle, they would make comments that sound as if they where on Twitter. LOL

Way back when the original Half-Life game came out and I played it on my ancient 3Dfx Voodoo card, the graphics blew me away. I've been loving the whole Half Life series and wait in anticipation for the next episode.
I was disappointed that there was not much news of Half-Life 2 Episode 3 this year, so lately I been going back into time to enjoy the beginning of Half Life 2. I thought Half-Life 1 set the bar.
This game set the bar again, the experience is so well done, that the replay value is good even for single player mode. I have lots PC games, once I finish one, I uninstall it. This is one of the few games I have worthy of staying installed for years.

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