lz.Keys is the single instance of the class
* lz.KeysService.
Here is a simple example:
* *lz.Keys.
*
* @type LzKeysService
* @keywords readonly
* @devnote this should be a public getter to enforce readonly
*/
public static const LzKeys:LzKeysService;
/** @access private */
function LzKeysService() {
super();
// if (LzKeysService.LzKeys) {
// throw new Error("There can be only one LzKeys");
// }
if ($as3) {
} else {
LzKeyboardKernel.setCallback(this, '__keyEvent');
}
if ($dhtml) {
// Need to explicitly register this. Make sure lz.embed.mousewheel is there for
// lztest
if (lz.embed['mousewheel']) {
lz.embed.mousewheel.setCallback(this, '__mousewheelEvent');
}
}
}
// Create the singleton
LzKeysService.LzKeys = new LzKeysService();
/**
* A hash where each of the keys that is currently
* down on the keyboard is set to true.
* @type Object
* @access private
*/
var downKeysHash :Object = {};
/**
* An array of currently pressed key codes.
* @type Array
* @access private
*/
var downKeysArray :Array = [];
/**
* An object used by callOnKeyCombo() to track key combinations
* @type Object
* @access private
*/
var keycombos :Object = {};
/**
* Sent when a key is pressed; sent with keycode
* for key that was pressed.
* @lzxtype event
* @access public
*/
var onkeydown :LzDeclaredEventClass = LzDeclaredEvent;
/**
* Sent whenever a key goes up; sent with keycode
* for key that was let go.
* @lzxtype event
* @access public
*/
var onkeyup :LzDeclaredEventClass = LzDeclaredEvent;
/**
* Sent when the mouse wheel changes state. Sent with a positive or
* negative number depending on the direction and amount the wheel moved.
* @lzxtype event
* @access public
*/
var onmousewheeldelta :LzDeclaredEventClass = LzDeclaredEvent;
/** For mapping key names (control, shift, alt) back to character codes
* @access private */
const codemap :Object = {shift: 16, control: 17, alt: 18};
/** Was the ctrl key set when the last key event came in
* @access private
*/
var ctrlKey:Boolean = false;
/** @access private */
function __keyEvent (delta:Object, k:Number, type:String, ctrlKey:Boolean=false) :void {
//Debug.write('__keyEvent', delta, k, type);
//for each key change, send the corresponding event
this.ctrlKey = ctrlKey;
var cm:Object = this.codemap;
for (var key:String in delta) {
var down:Boolean = delta[key];
if (cm[key] != null) k = cm[key];
if (down) {
this.gotKeyDown(k);
} else {
this.gotKeyUp(k);
}
}
}
/**
* Called whenever a key is pressed with the Flash keycode corresponding to
* the down key.
*
* @access private
* @param Number kC: The Flash keycode for the key that is down.
* @param String info: if "extra" then ignore if you already got one
*/
function gotKeyDown (kC:Number, info:String = null) :void {
//Debug.write('gotKeyDown', kC);
var dkhash:Object = this.downKeysHash;
var dkeys:Array = this.downKeysArray;
var firstkeydown:Boolean = !dkhash[ kC ];
if (firstkeydown) {
dkhash[ kC ] = true;
dkeys.push( kC );
dkeys.sort();
}
// send key down event first, so inputtext will get key event
// before a command that may change the focus
if (firstkeydown || info != "extra") {
// won't send repeated key events in player XXX ?
// check for IME
if (dkhash[229] != true) {
if (this.onkeydown.ready) this.onkeydown.sendEvent( kC );
}
}
if (firstkeydown) {
var cp:Object = this.keycombos;
for (var i:int = 0; i < dkeys.length && cp != null; i++) {
cp = cp[ dkeys[ i ] ];
}
if (cp != null && 'delegates' in cp) {
var del:Array = cp.delegates;
for (var i:int = 0; i < del.length; i++) {
del[ i ].execute( dkeys );
}
}
}
}
/**
* Called whenever the a key is released with the Flash keycode
* corresponding to the up key.
*
* @access private
* @param Number kC: The Flash keycode for the key that was released.
*/
function gotKeyUp (kC:Number) :void {
//Debug.write('gotKeyUp', kC);
var dkhash:Object = this.downKeysHash;
var dkeys:Array = this.downKeysArray = [];
var isDown:Boolean = dkhash[ kC ];
delete dkhash[ kC ];
if ($dhtml) {
// not necessary for DHTML
} else {
// LPP-7012 we don't get a key up from the 'v' in a command-v sequence on the mac.
// Workaround is to send all keys up when we see a 'command' (control) key-up event.
// (Only required for Flash)
if (kc == this.keyCodes.control) {
this.downKeysHash = {};
// Only send a key-up event if we know the key is already down
if (isDown && this.onkeyup.ready) this.onkeyup.sendEvent( kC );
// send all additional key-up events
for (var k:String in dkhash) {
if (this.onkeyup.ready) {
this.onkeyup.sendEvent( k );
}
}
return;
}
}
// update downKeysArray before sending onkeyup-event
for (var k:String in dkhash) {
dkeys.push( k );
}
// Only send a key-up event if we know the key is already down
if (isDown && this.onkeyup.ready) this.onkeyup.sendEvent( kC );
}
/**
* @return Boolean: indicating whether the given key(s) are down.
* @param k: The name of the key to check for downness or an array of
* key names, e.g. ['shift', 'tab']
*/
function isKeyDown (k:*) :Boolean {
if (typeof(k) == "string") {
return (this.downKeysHash[ this.keyCodes[ k.toLowerCase() ] ] == true);
} else {
// an array of keys was passed
var down:Boolean = true;
var dkhash:Object = this.downKeysHash;
var kc:Object = this.keyCodes;
for (var i:int = 0; i < k.length; i++) {
down = down && (dkhash[ kc[ k[i].toLowerCase() ] ] == true);
}
return down;
}
}
/**
* Instructs the service to call the given delegate whenever the
* given key combination is pressed.
* The names for recognized special keys are (case-insensitive):
*