armory3d.armortools/base/sources/ts/input.ts

let _input_occupied: bool   = false;
let _input_registered: bool = false;

function input_reset() {
	// _input_occupied = false;
	mouse_reset();
	pen_reset();
	keyboard_reset();
	/// if WITH_GAMEPAD
	gamepad_reset();
	/// end
}

function input_end_frame() {
	mouse_end_frame();
	pen_end_frame();
	keyboard_end_frame();
	/// if WITH_GAMEPAD
	gamepad_end_frame();
	/// end
}

function input_on_foreground() {
	mouse_reset(); // Reset mouse delta on foreground
}

function input_register() {
	if (_input_registered) {
		return;
	}
	_input_registered = true;
	keyboard_reset();
	mouse_reset();
	/// if WITH_GAMEPAD
	gamepad_reset();
	/// end
}

let _mouse_buttons: string[]        = [ "left", "right", "middle", "side1", "side2" ];
let _mouse_buttons_down: bool[]     = [ false, false, false, false, false ];
let _mouse_buttons_started: bool[]  = [ false, false, false, false, false ];
let _mouse_buttons_released: bool[] = [ false, false, false, false, false ];
let mouse_x: f32                    = -1.0;
let mouse_y: f32                    = -1.0;
let mouse_moved: bool               = false;
let mouse_movement_x: f32           = 0.0;
let mouse_movement_y: f32           = 0.0;
let mouse_wheel_delta: f32          = 0.0;
let mouse_last_x: f32               = -1.0;
let mouse_last_y: f32               = -1.0;

function mouse_end_frame() {
	_mouse_buttons_started[0] = _mouse_buttons_started[1] = _mouse_buttons_started[2] = _mouse_buttons_started[3] = _mouse_buttons_started[4] = false;
	_mouse_buttons_released[0] = _mouse_buttons_released[1] = _mouse_buttons_released[2] = _mouse_buttons_released[3] = _mouse_buttons_released[4] = false;
	mouse_moved                                                                                                                                    = false;
	mouse_movement_x                                                                                                                               = 0;
	mouse_movement_y                                                                                                                               = 0;
	mouse_wheel_delta                                                                                                                              = 0;
}

function mouse_reset() {
	_mouse_buttons_down[0] = _mouse_buttons_down[1] = _mouse_buttons_down[2] = _mouse_buttons_down[3] = _mouse_buttons_down[4] = false;
	mouse_end_frame();
}

function mouse_button_index(button: string): i32 {
	for (let i: i32 = 0; i < _mouse_buttons.length; ++i) {
		if (_mouse_buttons[i] == button) {
			return i;
		}
	}
	return 0;
}

function mouse_down(button: string = "left"): bool {
	return _mouse_buttons_down[mouse_button_index(button)];
}

function mouse_down_any(): bool {
	return _mouse_buttons_down[0] || _mouse_buttons_down[1] || _mouse_buttons_down[2] || _mouse_buttons_down[3] || _mouse_buttons_down[4];
}

function mouse_started(button: string = "left"): bool {
	return _mouse_buttons_started[mouse_button_index(button)];
}

function mouse_started_any(): bool {
	return _mouse_buttons_started[0] || _mouse_buttons_started[1] || _mouse_buttons_started[2] || _mouse_buttons_started[3] || _mouse_buttons_started[4];
}

function mouse_released(button: string = "left"): bool {
	return _mouse_buttons_released[mouse_button_index(button)];
}

function mouse_down_listener(index: i32, x: i32, y: i32) {
	if (pen_in_use) {
		return;
	}

	_mouse_buttons_down[index]    = true;
	_mouse_buttons_started[index] = true;
	mouse_x                       = x;
	mouse_y                       = y;
	/// if (arm_android || arm_ios) // For movement delta using touch
	if (index == 0) {
		mouse_last_x = x;
		mouse_last_y = y;
	}
	/// end
}

function mouse_up_listener(index: i32, x: i32, y: i32) {
	if (pen_in_use) {
		return;
	}

	_mouse_buttons_down[index]     = false;
	_mouse_buttons_released[index] = true;
	mouse_x                        = x;
	mouse_y                        = y;
}

function mouse_move_listener(x: i32, y: i32, movement_x: i32, movement_y: i32) {
	if (mouse_last_x == -1.0 && mouse_last_y == -1.0) { // First frame init
		mouse_last_x = x;
		mouse_last_y = y;
	}
	if (iron_mouse_is_locked()) {
		// Can be called multiple times per frame
		mouse_movement_x += movement_x;
		mouse_movement_y += movement_y;
	}
	else {
		mouse_movement_x += x - mouse_last_x;
		mouse_movement_y += y - mouse_last_y;
	}
	mouse_last_x = x;
	mouse_last_y = y;
	mouse_x      = x;
	mouse_y      = y;
	mouse_moved  = true;
}

function mouse_wheel_listener(delta: f32) {
	mouse_wheel_delta = delta;
}

/// if (arm_android || arm_ios)
function mouse_on_touch_down(index: i32, x: i32, y: i32) {
	if (index == 1) { // Two fingers down - right mouse button
		_mouse_buttons_down[0] = false;
		mouse_down_listener(1, math_floor(mouse_x), math_floor(mouse_y));
		mouse_pinch_started = true;
		mouse_pinch_total   = 0.0;
		mouse_pinch_dist    = 0.0;
	}
	else if (index == 2) { // Three fingers down - middle mouse button
		_mouse_buttons_down[1] = false;
		mouse_down_listener(2, math_floor(mouse_x), math_floor(mouse_y));
	}
}

function mouse_on_touch_up(index: i32, x: i32, y: i32) {
	if (index == 1) {
		mouse_up_listener(1, math_floor(mouse_x), math_floor(mouse_y));
	}
	else if (index == 2) {
		mouse_up_listener(2, math_floor(mouse_x), math_floor(mouse_y));
	}
}

let mouse_pinch_dist: f32     = 0.0;
let mouse_pinch_total: f32    = 0.0;
let mouse_pinch_started: bool = false;

function mouse_on_touch_move(index: i32, x: i32, y: i32) {
	// Pinch to zoom - mouse wheel
	if (index == 1) {
		let last_dist: f32 = mouse_pinch_dist;
		let dx: f32        = mouse_x - x;
		let dy: f32        = mouse_y - y;
		mouse_pinch_dist   = math_sqrt(dx * dx + dy * dy);
		mouse_pinch_total += last_dist != 0 ? last_dist - mouse_pinch_dist : 0;
		if (!mouse_pinch_started) {
			mouse_wheel_delta = mouse_pinch_total / 10.0;
			if (mouse_wheel_delta != 0.0) {
				mouse_pinch_total = 0.0;
			}
		}
		mouse_pinch_started = false;
	}
}
/// end

function mouse_view_x(): f32 {
	return mouse_x - sys_x();
}

function mouse_view_y(): f32 {
	return mouse_y - sys_y();
}

let pen_buttons: string[]        = [ "tip" ];
let pen_buttons_down: bool[]     = [ false ];
let pen_buttons_started: bool[]  = [ false ];
let pen_buttons_released: bool[] = [ false ];
let pen_x: f32                   = 0.0;
let pen_y: f32                   = 0.0;
let pen_moved: bool              = false;
let pen_movement_x: f32          = 0.0;
let pen_movement_y: f32          = 0.0;
let pen_pressure: f32            = 0.0;
let pen_connected: bool          = false;
let pen_in_use: bool             = false;
let pen_last_x: f32              = -1.0;
let pen_last_y: f32              = -1.0;

function pen_end_frame() {
	pen_buttons_started[0]  = false;
	pen_buttons_released[0] = false;
	pen_moved               = false;
	pen_movement_x          = 0;
	pen_movement_y          = 0;
	pen_in_use              = false;
}

function pen_reset() {
	pen_buttons_down[0] = false;
	pen_end_frame();
}

function pen_button_index(button: string): i32 {
	return 0;
}

function pen_down(button: string = "tip"): bool {
	return pen_buttons_down[pen_button_index(button)];
}

function pen_started(button: string = "tip"): bool {
	return pen_buttons_started[pen_button_index(button)];
}

function pen_released(button: string = "tip"): bool {
	return pen_buttons_released[pen_button_index(button)];
}

function pen_down_listener(x: i32, y: i32, pressure: f32) {
	pen_buttons_down[0]    = true;
	pen_buttons_started[0] = true;
	pen_x                  = x;
	pen_y                  = y;
	pen_pressure           = pressure;

	/// if (!arm_android && !arm_ios)
	mouse_down_listener(0, x, y);
	/// end
}

function pen_up_listener(x: i32, y: i32, pressure: f32) {
	/// if (!arm_android && !arm_ios)
	if (pen_buttons_started[0]) {
		pen_buttons_started[0] = false;
		pen_in_use             = true;
		return;
	}
	/// end

	pen_buttons_down[0]     = false;
	pen_buttons_released[0] = true;
	pen_x                   = x;
	pen_y                   = y;
	pen_pressure            = pressure;

	/// if (!arm_android && !arm_ios)
	mouse_up_listener(0, x, y);
	pen_in_use = true; // On pen release, additional mouse down & up events are fired at once - filter those out
	                   /// end
}

function pen_move_listener(x: i32, y: i32, pressure: f32) {
	/// if arm_ios
	// Listen to pen hover if no other input is active
	if (!pen_buttons_down[0] && pressure == 0.0) {
		if (!mouse_down_any()) {
			mouse_move_listener(x, y, 0, 0);
		}
		return;
	}
	/// end

	if (pen_last_x == -1.0 && pen_last_y == -1.0) { // First frame init
		pen_last_x = x;
		pen_last_y = y;
	}
	pen_movement_x = x - pen_last_x;
	pen_movement_y = y - pen_last_y;
	pen_last_x     = x;
	pen_last_y     = y;
	pen_x          = x;
	pen_y          = y;
	pen_moved      = true;
	pen_pressure   = pressure;
	pen_connected  = true;
}

function pen_view_x(): f32 {
	return pen_x - sys_x();
}

function pen_view_y(): f32 {
	return pen_y - sys_y();
}

let keyboard_keys: string[] = [
	"a",   "b",     "c",     "d",       "e",   "f",   "g",      "h",      "i",  "j",    "k",    "l",     "m",    "n",  "o",   "p",   "q",  "r",     "s",
	"t",   "u",     "v",     "w",       "x",   "y",   "z",      "0",      "1",  "2",    "3",    "4",     "5",    "6",  "7",   "8",   "9",  "space", "backspace",
	"tab", "enter", "shift", "control", "alt", "win", "escape", "delete", "up", "down", "left", "right", "back", ",",  ".",   ":",   ";",  "<",     "=",
	">",   "?",     "!",     "\"",      "#",   "$",   "%",      "&",      "_",  "(",    ")",    "*",     "|",    "{",  "}",   "[",   "]",  "~",     "`",
	"/",   "\\",    "@",     "+",       "-",   "f1",  "f2",     "f3",     "f4", "f5",   "f6",   "f7",    "f8",   "f9", "f10", "f11", "f12"
];
let keyboard_keys_down: map_t<string, bool>     = map_create();
let keyboard_keys_started: map_t<string, bool>  = map_create();
let keyboard_keys_released: map_t<string, bool> = map_create();
let keyboard_keys_frame: string[]               = [];
let keyboard_repeat_key: bool                   = false;
let keyboard_repeat_time: f32                   = 0.0;

function keyboard_end_frame() {
	if (keyboard_keys_frame.length > 0) {
		for (let i: i32 = 0; i < keyboard_keys_frame.length; ++i) {
			let s: string = keyboard_keys_frame[i];
			map_set(keyboard_keys_started, s, false);
			map_set(keyboard_keys_released, s, false);
		}
		array_splice(keyboard_keys_frame, 0, keyboard_keys_frame.length);
	}

	if (sys_time() - keyboard_repeat_time > 0.05) {
		keyboard_repeat_time = sys_time();
		keyboard_repeat_key  = true;
	}
	else {
		keyboard_repeat_key = false;
	}
}

function keyboard_reset() {
	// Use map_t for now..
	for (let i: i32 = 0; i < keyboard_keys.length; ++i) {
		let s: string = keyboard_keys[i];
		map_set(keyboard_keys_down, s, false);
		map_set(keyboard_keys_started, s, false);
		map_set(keyboard_keys_released, s, false);
	}
	keyboard_end_frame();
}

function keyboard_down(key: string): bool {
	return map_get(keyboard_keys_down, key);
}

function keyboard_started(key: string): bool {
	return map_get(keyboard_keys_started, key);
}

function keyboard_started_any(): bool {
	return keyboard_keys_frame.length > 0;
}

function keyboard_released(key: string): bool {
	return map_get(keyboard_keys_released, key);
}

function keyboard_repeat(key: string): bool {
	return map_get(keyboard_keys_started, key) || (keyboard_repeat_key && map_get(keyboard_keys_down, key));
}

function keyboard_key_code(key: key_code_t): string {
	if (key == key_code_t.SPACE) {
		return "space";
	}
	if (key == key_code_t.BACKSPACE) {
		return "backspace";
	}
	if (key == key_code_t.TAB) {
		return "tab";
	}
	if (key == key_code_t.RETURN) {
		return "enter";
	}
	if (key == key_code_t.SHIFT) {
		return "shift";
	}
	if (key == key_code_t.CONTROL) {
		return "control";
	}
	/// if arm_macos
	if (key == key_code_t.META) {
		return "control";
	}
	/// end
	if (key == key_code_t.ALT) {
		return "alt";
	}
	if (key == key_code_t.WIN) {
		return "win";
	}
	if (key == key_code_t.ESCAPE) {
		return "escape";
	}
	if (key == key_code_t.DELETE) {
		return "delete";
	}
	if (key == key_code_t.UP) {
		return "up";
	}
	if (key == key_code_t.DOWN) {
		return "down";
	}
	if (key == key_code_t.LEFT) {
		return "left";
	}
	if (key == key_code_t.RIGHT) {
		return "right";
	}
	if (key == key_code_t.BACK) {
		return "back";
	}
	if (key == key_code_t.COMMA) {
		return ",";
	}
	if (key == key_code_t.PERIOD) {
		return ".";
	}
	if (key == key_code_t.COLON) {
		return ":";
	}
	if (key == key_code_t.SEMICOLON) {
		return ";";
	}
	if (key == key_code_t.LESS_THAN) {
		return "<";
	}
	if (key == key_code_t.EQUALS) {
		return "=";
	}
	if (key == key_code_t.GREATER_THAN) {
		return ">";
	}
	if (key == key_code_t.QUESTION_MARK) {
		return "?";
	}
	if (key == key_code_t.EXCLAMATION) {
		return "!";
	}
	if (key == key_code_t.DOUBLE_QUOTE) {
		return "\"";
	}
	if (key == key_code_t.HASH) {
		return "#";
	}
	if (key == key_code_t.DOLLAR) {
		return "$";
	}
	if (key == key_code_t.PERCENT) {
		return "%";
	}
	if (key == key_code_t.AMPERSAND) {
		return "&";
	}
	if (key == key_code_t.UNDERSCORE) {
		return "_";
	}
	if (key == key_code_t.OPEN_PAREN) {
		return "(";
	}
	if (key == key_code_t.CLOSE_PAREN) {
		return ")";
	}
	if (key == key_code_t.ASTERISK) {
		return "*";
	}
	if (key == key_code_t.PIPE) {
		return "|";
	}
	if (key == key_code_t.OPEN_CURLY_BRACKET) {
		return "{";
	}
	if (key == key_code_t.CLOSE_CURLY_BRACKET) {
		return "}";
	}
	if (key == key_code_t.OPEN_BRACKET) {
		return "[";
	}
	if (key == key_code_t.CLOSE_BRACKET) {
		return "]";
	}
	if (key == key_code_t.TILDE) {
		return "~";
	}
	if (key == key_code_t.BACK_QUOTE) {
		return "`";
	}
	if (key == key_code_t.SLASH) {
		return "/";
	}
	if (key == key_code_t.BACK_SLASH) {
		return "\\";
	}
	if (key == key_code_t.AT) {
		return "@";
	}
	if (key == key_code_t.ADD) {
		return "+";
	}
	if (key == key_code_t.PLUS) {
		return "+";
	}
	if (key == key_code_t.SUBTRACT) {
		return "-";
	}
	if (key == key_code_t.HYPHEN_MINUS) {
		return "-";
	}
	if (key == key_code_t.MULTIPLY) {
		return "*";
	}
	if (key == key_code_t.DIVIDE) {
		return "/";
	}
	if (key == key_code_t.DECIMAL) {
		return ".";
	}
	if (key == key_code_t.ZERO) {
		return "0";
	}
	if (key == key_code_t.NUMPAD0) {
		return "0";
	}
	if (key == key_code_t.ONE) {
		return "1";
	}
	if (key == key_code_t.NUMPAD1) {
		return "1";
	}
	if (key == key_code_t.TWO) {
		return "2";
	}
	if (key == key_code_t.NUMPAD2) {
		return "2";
	}
	if (key == key_code_t.THREE) {
		return "3";
	}
	if (key == key_code_t.NUMPAD3) {
		return "3";
	}
	if (key == key_code_t.FOUR) {
		return "4";
	}
	if (key == key_code_t.NUMPAD4) {
		return "4";
	}
	if (key == key_code_t.FIVE) {
		return "5";
	}
	if (key == key_code_t.NUMPAD5) {
		return "5";
	}
	if (key == key_code_t.SIX) {
		return "6";
	}
	if (key == key_code_t.NUMPAD6) {
		return "6";
	}
	if (key == key_code_t.SEVEN) {
		return "7";
	}
	if (key == key_code_t.NUMPAD7) {
		return "7";
	}
	if (key == key_code_t.EIGHT) {
		return "8";
	}
	if (key == key_code_t.NUMPAD8) {
		return "8";
	}
	if (key == key_code_t.NINE) {
		return "9";
	}
	if (key == key_code_t.NUMPAD9) {
		return "9";
	}
	if (key == key_code_t.F1) {
		return "f1";
	}
	if (key == key_code_t.F2) {
		return "f2";
	}
	if (key == key_code_t.F3) {
		return "f3";
	}
	if (key == key_code_t.F4) {
		return "f4";
	}
	if (key == key_code_t.F5) {
		return "f5";
	}
	if (key == key_code_t.F6) {
		return "f6";
	}
	if (key == key_code_t.F7) {
		return "f7";
	}
	if (key == key_code_t.F8) {
		return "f8";
	}
	if (key == key_code_t.F9) {
		return "f9";
	}
	if (key == key_code_t.F10) {
		return "f10";
	}
	if (key == key_code_t.F11) {
		return "f11";
	}
	if (key == key_code_t.F12) {
		return "f12";
	}
	return to_lower_case(string_from_char_code(key));
}

function keyboard_down_listener(code: key_code_t) {
	let s: string = keyboard_key_code(code);
	array_push(keyboard_keys_frame, s);
	map_set(keyboard_keys_started, s, true);
	map_set(keyboard_keys_down, s, true);
	keyboard_repeat_time = sys_time() + 0.4;

	/// if arm_android_rmb // Detect right mouse button on Android..
	if (code == key_code_t.BACK) {
		if (!_mouse_buttons_down[1]) {
			mouse_down_listener(1, math_floor(mouse_x), math_floor(mouse_y));
		}
	}
	/// end
}

function keyboard_up_listener(code: key_code_t) {
	let s: string = keyboard_key_code(code);
	array_push(keyboard_keys_frame, s);
	map_set(keyboard_keys_released, s, true);
	map_set(keyboard_keys_down, s, false);

	/// if arm_android_rmb
	if (code == key_code_t.BACK) {
		mouse_up_listener(1, math_floor(mouse_x), math_floor(mouse_y));
	}
	/// end
}

/// if WITH_GAMEPAD

let gamepad_buttons_ps: string[] =
    [ "cross", "circle", "square", "triangle", "l1", "r1", "l2", "r2", "share", "options", "l3", "r3", "up", "down", "left", "right", "home", "touchpad" ];
let gamepad_buttons_xbox: string[] =
    [ "a", "b", "x", "y", "l1", "r1", "l2", "r2", "share", "options", "l3", "r3", "up", "down", "left", "right", "home", "touchpad" ];
let gamepad_buttons: string[] = gamepad_buttons_ps;
let gamepad_raws: gamepad_t[];

function gamepad_end_frame() {
	// TODO: check valgrind error
	// for (let i: i32 = 0; i < gamepad_raws.length; ++i) {
	// 	let g: gamepad_t = gamepad_raws[i];
	// 	if (g.buttons_frame.length > 0) {
	// 		for (let j: i32 = 0; j < g.buttons_frame.length; ++j) {
	// 			let b: i32 = g.buttons_frame[j];
	// 			g.buttons_started[b] = false;
	// 			g.buttons_released[b] = false;
	// 		}
	// 		array_splice(g.buttons_frame, 0, g.buttons_frame.length);
	// 	}
	// 	g.left_stick.moved = false;
	// 	g.left_stick.movement_x = 0;
	// 	g.left_stick.movement_y = 0;
	// 	g.right_stick.moved = false;
	// 	g.right_stick.movement_x = 0;
	// 	g.right_stick.movement_y = 0;
	// }
}

function gamepad_stick_create(): gamepad_stick_t {
	let raw: gamepad_stick_t = {};
	raw.x                    = 0.0;
	raw.y                    = 0.0;
	raw.last_x               = 0.0;
	raw.last_y               = 0.0;
	raw.moved                = false;
	raw.movement_x           = 0.0;
	raw.movement_y           = 0.0;
	return raw;
}

function gamepad_create(): gamepad_t {
	let raw: gamepad_t   = {};
	raw.buttons_down     = [];
	raw.buttons_started  = [];
	raw.buttons_released = [];
	raw.buttons_frame    = [];
	raw.left_stick       = gamepad_stick_create();
	raw.right_stick      = gamepad_stick_create();
	return raw;
}

function gamepad_reset() {
	gamepad_raws = [];
	for (let i: i32 = 0; i < 4; ++i) {
		let g: gamepad_t = gamepad_create();
		array_push(gamepad_raws, g);
		for (let i: i32 = 0; i < gamepad_buttons.length; ++i) {
			array_push(g.buttons_down, 0.0);
			array_push(g.buttons_started, false);
			array_push(g.buttons_released, false);
		}
	}

	gamepad_end_frame();
}

function gamepad_key_code(button: i32): string {
	return gamepad_buttons[button];
}

function gamepad_button_index(button: string): i32 {
	for (let i: i32 = 0; i < gamepad_buttons.length; ++i) {
		if (gamepad_buttons[i] == button) {
			return i;
		}
	}
	return 0;
}

function gamepad_down(i: i32, button: string): f32 {
	return gamepad_raws[i].buttons_down[gamepad_button_index(button)];
}

function gamepad_started(i: i32, button: string): bool {
	return gamepad_raws[i].buttons_started[gamepad_button_index(button)];
}

function gamepad_released(i: i32, button: string): bool {
	return gamepad_raws[i].buttons_released[gamepad_button_index(button)];
}

function gamepad_axis_listener(i: i32, axis: i32, value: f32) {
	let stick: gamepad_stick_t = axis <= 1 ? gamepad_raws[i].left_stick : gamepad_raws[i].right_stick;

	if (axis == 0 || axis == 2) { // X
		stick.last_x     = stick.x;
		stick.x          = value;
		stick.movement_x = stick.x - stick.last_x;
	}
	else if (axis == 1 || axis == 3) { // Y
		stick.last_y     = stick.y;
		stick.y          = value;
		stick.movement_y = stick.y - stick.last_y;
	}
	stick.moved = true;
}

function gamepad_button_listener(i: i32, button: i32, value: f32) {
	// array_push(gamepad_raws[i].buttons_frame, button);

	// gamepad_raws[i].buttons_down[button] = value;
	// if (value > 0) {
	// 	gamepad_raws[i].buttons_started[button] = true; // Will trigger L2/R2 multiple times..
	// }
	// else {
	// 	gamepad_raws[i].buttons_released[button] = true;
	// }
}

type gamepad_stick_t = {
	x?: f32;
	y?: f32;
	last_x?: f32;
	last_y?: f32;
	moved?: bool;
	movement_x?: f32;
	movement_y?: f32;
};

type gamepad_t = {
	buttons_down?: f32[]; // Intensity 0 - 1
	buttons_started?: bool[];
	buttons_released?: bool[];
	buttons_frame?: i32[];
	left_stick?: gamepad_stick_t;
	right_stick?: gamepad_stick_t;
};

/// end

enum key_code_t {
	UNKNOWN             = 0,
	BACK                = 1, // Android
	CANCEL              = 3,
	HELP                = 6,
	BACKSPACE           = 8,
	TAB                 = 9,
	RETURN              = 13,
	SHIFT               = 16,
	CONTROL             = 17,
	ALT                 = 18,
	PAUSE               = 19,
	CAPS_LOCK           = 20,
	ESCAPE              = 27,
	SPACE               = 32,
	PAGE_UP             = 33,
	PAGE_DOWN           = 34,
	END                 = 35,
	HOME                = 36,
	LEFT                = 37,
	UP                  = 38,
	RIGHT               = 39,
	DOWN                = 40,
	PRINT_SCREEN        = 44,
	INSERT              = 45,
	DELETE              = 46,
	ZERO                = 48,
	ONE                 = 49,
	TWO                 = 50,
	THREE               = 51,
	FOUR                = 52,
	FIVE                = 53,
	SIX                 = 54,
	SEVEN               = 55,
	EIGHT               = 56,
	NINE                = 57,
	COLON               = 58,
	SEMICOLON           = 59,
	LESS_THAN           = 60,
	EQUALS              = 61,
	GREATER_THAN        = 62,
	QUESTION_MARK       = 63,
	AT                  = 64,
	A                   = 65,
	B                   = 66,
	C                   = 67,
	D                   = 68,
	E                   = 69,
	F                   = 70,
	G                   = 71,
	H                   = 72,
	I                   = 73,
	J                   = 74,
	K                   = 75,
	L                   = 76,
	M                   = 77,
	N                   = 78,
	O                   = 79,
	P                   = 80,
	Q                   = 81,
	R                   = 82,
	S                   = 83,
	T                   = 84,
	U                   = 85,
	V                   = 86,
	W                   = 87,
	X                   = 88,
	Y                   = 89,
	Z                   = 90,
	WIN                 = 91,
	CONTEXT_MENU        = 93,
	SLEEP               = 95,
	NUMPAD0             = 96,
	NUMPAD1             = 97,
	NUMPAD2             = 98,
	NUMPAD3             = 99,
	NUMPAD4             = 100,
	NUMPAD5             = 101,
	NUMPAD6             = 102,
	NUMPAD7             = 103,
	NUMPAD8             = 104,
	NUMPAD9             = 105,
	MULTIPLY            = 106,
	ADD                 = 107,
	SEPARATOR           = 108,
	SUBTRACT            = 109,
	DECIMAL             = 110,
	DIVIDE              = 111,
	F1                  = 112,
	F2                  = 113,
	F3                  = 114,
	F4                  = 115,
	F5                  = 116,
	F6                  = 117,
	F7                  = 118,
	F8                  = 119,
	F9                  = 120,
	F10                 = 121,
	F11                 = 122,
	F12                 = 123,
	F13                 = 124,
	F14                 = 125,
	F15                 = 126,
	F16                 = 127,
	F17                 = 128,
	F18                 = 129,
	F19                 = 130,
	F20                 = 131,
	F21                 = 132,
	F22                 = 133,
	F23                 = 134,
	F24                 = 135,
	NUM_LOCK            = 144,
	SCROLL_LOCK         = 145,
	EXCLAMATION         = 161,
	DOUBLE_QUOTE        = 162,
	HASH                = 163,
	DOLLAR              = 164,
	PERCENT             = 165,
	AMPERSAND           = 166,
	UNDERSCORE          = 167,
	OPEN_PAREN          = 168,
	CLOSE_PAREN         = 169,
	ASTERISK            = 170,
	PLUS                = 171,
	PIPE                = 172,
	HYPHEN_MINUS        = 173,
	OPEN_CURLY_BRACKET  = 174,
	CLOSE_CURLY_BRACKET = 175,
	TILDE               = 176,
	VOLUME_MUTE         = 181,
	VOLUME_DOWN         = 182,
	VOLUME_UP           = 183,
	COMMA               = 188,
	PERIOD              = 190,
	SLASH               = 191,
	BACK_QUOTE          = 192,
	OPEN_BRACKET        = 219,
	BACK_SLASH          = 220,
	CLOSE_BRACKET       = 221,
	QUOTE               = 222,
	META                = 224,
	ALTGR               = 225,
}