Just for fun I wrote a simple ShortcutManager this evening, it turned out to be an interesting little project and taught me a few things about Functions. It’s by no means finished, I’ll detail a few planned improvements after I go over it’s usage.

My goals were to have a static registry that the application could register a keyCode, along with a qualifying key combination (I refer to this as “pair” in the code) like CTRL, or CTRL-ALT. I left out ALT, as Windows seems to have issues with giving up control of the ALT key when used alone. Along with the keyCode, I needed to be able to register a function that would be called when the key combination was pressed. I also wanted to be able to remove a key combination at runtime.

My data structure was simple, I used a separate Dictionary for each of the key combinations I was supporting.

private static var ctrlFunctionMap : Dictionary = new Dictionary();
private static var ctrlAltFunctionMap : Dictionary = new Dictionary();

I wrote an addShortcut method that accepted the keyCode integer, the function to be called, and a string declaring the combination key(s). In it I simply associated the keycode and the function in the appropriate Dictionary. Here is the addShortcut():

public static function addShortcut(keycode : uint, func : Function, pair : String = "ctrl") : void {
	if (pair == "ctrl") {
		ctrlFunctionMap[keycode] = func;
	}
	else if (pair == "ctrlAlt") {
		ctrlAltFunctionMap[keycode] = func;
	}
	else {
		trace("Key combination not supported.");
	}
}

The removeShortcut() method has a similar structure, with one less parameter since we don’t need to know the function. We simply set the appropriate function for the appropriate keycode and combination key to null. Here is the removeShortcut() function:

public static function removeShortcut(keycode : uint, pair : String = "ctrl") : void {
	if (pair == "ctrl") {
		ctrlFunctionMap[keycode] = null;
	}
	else if (pair == "ctrlAlt") {
		ctrlAltFunctionMap[keycode] = null;
	}
	else {
		trace("Key combination not supported.");
	}
}

Finally we need a method that accepts a KeyboardEvent and determines if one of the functions needs to be executed, and then call it. Here is the shortcutHandler() function that does this:

public static function shortcutHandler(event : KeyboardEvent) : void {
	if ( event.ctrlKey && !event.altKey && (ctrlFunctionMap[event.keyCode] != null) ) {
		(ctrlFunctionMap[event.keyCode] as Function).apply();
	}
	else if (event.ctrlKey && event.altKey && (ctrlAltFunctionMap[event.keyCode] != null) ) {
		(ctrlAltFunctionMap[event.keyCode] as Function).apply();
	}
}

I learned an important lesson when I first tried to implement this method. I tried casting the value from the map as a Function, like this:

Function(ctrlFunctionMap[event.keyCode]).apply();

which didn’t work, and spat the error:

EvalError: Error #1066: The form function('function body') is not  supported.

Fortunately, one of ActionScript’s more descriptive error messages (I could tell by the parentheses what was wrong) and was able to correct it using the as operator. I didn’t try it, but I might have been able to not bother casting it at all.

Here’s my ShortcutManagerDemo application, demonstrating how it can be used with a variety of functions and function literals.

import com.googolflex.gflib.managers.ShortcutManager;

private function onCreationComplete() : void {
	ShortcutManager.addShortcut(89, onCtrlY, "ctrl");
	ShortcutManager.addShortcut(89, onAltY, "ctrlAlt");

	var f : Function = function():void { trace("Ctrl-U pressed."); }
	ShortcutManager.addShortcut(85, f, "ctrl");
	ShortcutManager.addShortcut(85,
		function():void { trace("Ctrl-Alt-U pressed."); },
		"ctrlAlt");
}

private function onAddedToStage() : void {
	stage.addEventListener(KeyboardEvent.KEY_DOWN, globalShortcutHandler);
}

private function globalShortcutHandler(event : KeyboardEvent) : void {
	ShortcutManager.shortcutHandler(event);
}

private function onCtrlY() : void {
	trace("Control-Y pressed.");
}

private function onAltY() : void {
	trace("Ctrl-Alt-Y pressed.");
}

I’ll post the code for the manager, and the sample application at the end of the post. Anyway, some improvements I’m planning…

I’d like to associate a context with each command, so that the same keyCodes could be used on different screens. Organizing the manager for such functionality doesn’t strike me as being that hard. I would have to make some changes to my logic to keep down the “conditional explosion”. The daunting part is where to get the context state… I’ll probably end up creating an interface for it, and then make my models implement it.

Of course I’d like to add more combination keys: SHIFT, SHIFT-ALT, CTRL-SHIFT-ALT, etc. The challenging part for that will be simplifying the conditional logic in shortcutHandler() to keep from having to check for a billion cases. I think I would start by pushing the (ctrlFunctionMap[event.keyCode] != null) check down a level, and using my first level of logic only to check the combination keys pressed.

Anyway, if this is useful for anyone I’m glad I could help. Here’s the source:

ShortcutManagerDemo.mxml
ShortcutManager.zip

Update (8/18/09): I added a few things to ShortcutManagerDemo.mxml, namely an interface that allows the user to add their own key commands at runtime. This has limited usefulness in it’s present form, as the functions themselves are still fixed at compile time. Here are some keycodes you can try it out on, anyhow.

a-65; b-66; c-67… 0-48; 1-49; 2-50…