quakeforge/libs/video/targets/keys.c

/*
	keys.c

	(description)

	Copyright (C) 1996-1997  Id Software, Inc.

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>

#include "QF/cbuf.h"
#include "QF/cmd.h"
#include "QF/console.h"
#include "QF/csqc.h"
#include "QF/cvar.h"
#include "QF/keys.h"
#include "QF/screen.h"
#include "QF/sys.h"
#include "QF/zone.h"
#include "QF/gib.h"

#include "compat.h"
#include "old_keys.h"

#define U __attribute__ ((used))
static U void (*const key_progs_init)(struct progs_s *) = Key_Progs_Init;
#undef U

/*  key up events are sent even if in console mode */

static keydest_t    key_dest = key_console;
static keytarget_t  key_targets[key_last];
VISIBLE knum_t      key_togglemenu = QFK_ESCAPE;
VISIBLE knum_t      key_toggleconsole = QFK_BACKQUOTE;

#define KEYDEST_CALLBACK_CHUNK 16
static keydest_callback_t **keydest_callbacks;
static int num_keydest_callbacks;
static int max_keydest_callbacks;

VISIBLE int			keydown[QFK_LAST];

static int  keyhelp;
static cbuf_t *cbuf;

static const char *keydest_names[] = {
	"key_unfocused",
	"key_game",
	"key_demo",
	"key_console",
	"key_message",
	"key_menu",

	"key_last"
};


typedef struct {
	const char *name;
	imt_t	imtnum;
} imtname_t;

typedef struct {
	const char *name;
	knum_t	keynum;
} keyname_t;

keyname_t   keynames[] = {
	{ "K_UNKNOWN",		QFK_UNKNOWN },
	{ "K_FIRST",		QFK_FIRST },
	{ "K_BACKSPACE",	QFK_BACKSPACE },
	{ "K_TAB",			QFK_TAB },
	{ "K_CLEAR",		QFK_CLEAR },
	{ "K_RETURN",		QFK_RETURN },
	{ "K_PAUSE",		QFK_PAUSE },
	{ "K_ESCAPE",		QFK_ESCAPE },
	{ "K_SPACE",		QFK_SPACE },
	{ "K_EXCLAIM",		QFK_EXCLAIM },
	{ "K_QUOTEDBL",		QFK_QUOTEDBL },
	{ "K_HASH",			QFK_HASH },
	{ "K_DOLLAR",		QFK_DOLLAR },
	{ "K_PERCENT",		QFK_PERCENT },
	{ "K_AMPERSAND",	QFK_AMPERSAND },
	{ "K_QUOTE",		QFK_QUOTE },
	{ "K_LEFTPAREN",	QFK_LEFTPAREN },
	{ "K_RIGHTPAREN",	QFK_RIGHTPAREN },
	{ "K_ASTERISK",		QFK_ASTERISK },
	{ "K_PLUS",			QFK_PLUS },
	{ "K_COMMA",		QFK_COMMA },
	{ "K_MINUS",		QFK_MINUS },
	{ "K_PERIOD",		QFK_PERIOD },
	{ "K_SLASH",		QFK_SLASH },
	{ "K_0",			QFK_0 },
	{ "K_1",			QFK_1 },
	{ "K_2",			QFK_2 },
	{ "K_3",			QFK_3 },
	{ "K_4",			QFK_4 },
	{ "K_5",			QFK_5 },
	{ "K_6",			QFK_6 },
	{ "K_7",			QFK_7 },
	{ "K_8",			QFK_8 },
	{ "K_9",			QFK_9 },
	{ "K_COLON",		QFK_COLON },
	{ "K_SEMICOLON",	QFK_SEMICOLON },
	{ "K_LESS",			QFK_LESS },
	{ "K_EQUALS",		QFK_EQUALS },
	{ "K_GREATER",		QFK_GREATER },
	{ "K_QUESTION",		QFK_QUESTION },
	{ "K_AT",			QFK_AT },
	{ "K_LEFTBRACKET",	QFK_LEFTBRACKET },
	{ "K_BACKSLASH",	QFK_BACKSLASH },
	{ "K_RIGHTBRACKET",	QFK_RIGHTBRACKET },
	{ "K_CARET",		QFK_CARET },
	{ "K_UNDERSCORE",	QFK_UNDERSCORE },
	{ "K_BACKQUOTE",	QFK_BACKQUOTE },
	{ "K_a",			QFK_a },
	{ "K_b",			QFK_b },
	{ "K_c",			QFK_c },
	{ "K_d",			QFK_d },
	{ "K_e",			QFK_e },
	{ "K_f",			QFK_f },
	{ "K_g",			QFK_g },
	{ "K_h",			QFK_h },
	{ "K_i",			QFK_i },
	{ "K_j",			QFK_j },
	{ "K_k",			QFK_k },
	{ "K_l",			QFK_l },
	{ "K_m",			QFK_m },
	{ "K_n",			QFK_n },
	{ "K_o",			QFK_o },
	{ "K_p",			QFK_p },
	{ "K_q",			QFK_q },
	{ "K_r",			QFK_r },
	{ "K_s",			QFK_s },
	{ "K_t",			QFK_t },
	{ "K_u",			QFK_u },
	{ "K_v",			QFK_v },
	{ "K_w",			QFK_w },
	{ "K_x",			QFK_x },
	{ "K_y",			QFK_y },
	{ "K_z",			QFK_z },
	{ "K_BRACELEFT",	QFK_BRACELEFT },
	{ "K_BAR",			QFK_BAR },
	{ "K_BRACERIGHT",	QFK_BRACERIGHT },
	{ "K_ASCIITILDE",	QFK_ASCIITILDE },
	{ "K_DELETE",		QFK_DELETE },
	{ "K_WORLD_0",		QFK_WORLD_0 },
	{ "K_WORLD_1",		QFK_WORLD_1 },
	{ "K_WORLD_2",		QFK_WORLD_2 },
	{ "K_WORLD_3",		QFK_WORLD_3 },
	{ "K_WORLD_4",		QFK_WORLD_4 },
	{ "K_WORLD_5",		QFK_WORLD_5 },
	{ "K_WORLD_6",		QFK_WORLD_6 },
	{ "K_WORLD_7",		QFK_WORLD_7 },
	{ "K_WORLD_8",		QFK_WORLD_8 },
	{ "K_WORLD_9",		QFK_WORLD_9 },
	{ "K_WORLD_10",		QFK_WORLD_10 },
	{ "K_WORLD_11",		QFK_WORLD_11 },
	{ "K_WORLD_12",		QFK_WORLD_12 },
	{ "K_WORLD_13",		QFK_WORLD_13 },
	{ "K_WORLD_14",		QFK_WORLD_14 },
	{ "K_WORLD_15",		QFK_WORLD_15 },
	{ "K_WORLD_16",		QFK_WORLD_16 },
	{ "K_WORLD_17",		QFK_WORLD_17 },
	{ "K_WORLD_18",		QFK_WORLD_18 },
	{ "K_WORLD_19",		QFK_WORLD_19 },
	{ "K_WORLD_20",		QFK_WORLD_20 },
	{ "K_WORLD_21",		QFK_WORLD_21 },
	{ "K_WORLD_22",		QFK_WORLD_22 },
	{ "K_WORLD_23",		QFK_WORLD_23 },
	{ "K_WORLD_24",		QFK_WORLD_24 },
	{ "K_WORLD_25",		QFK_WORLD_25 },
	{ "K_WORLD_26",		QFK_WORLD_26 },
	{ "K_WORLD_27",		QFK_WORLD_27 },
	{ "K_WORLD_28",		QFK_WORLD_28 },
	{ "K_WORLD_29",		QFK_WORLD_29 },
	{ "K_WORLD_30",		QFK_WORLD_30 },
	{ "K_WORLD_31",		QFK_WORLD_31 },
	{ "K_WORLD_32",		QFK_WORLD_32 },
	{ "K_WORLD_33",		QFK_WORLD_33 },
	{ "K_WORLD_34",		QFK_WORLD_34 },
	{ "K_WORLD_35",		QFK_WORLD_35 },
	{ "K_WORLD_36",		QFK_WORLD_36 },
	{ "K_WORLD_37",		QFK_WORLD_37 },
	{ "K_WORLD_38",		QFK_WORLD_38 },
	{ "K_WORLD_39",		QFK_WORLD_39 },
	{ "K_WORLD_40",		QFK_WORLD_40 },
	{ "K_WORLD_41",		QFK_WORLD_41 },
	{ "K_WORLD_42",		QFK_WORLD_42 },
	{ "K_WORLD_43",		QFK_WORLD_43 },
	{ "K_WORLD_44",		QFK_WORLD_44 },
	{ "K_WORLD_45",		QFK_WORLD_45 },
	{ "K_WORLD_46",		QFK_WORLD_46 },
	{ "K_WORLD_47",		QFK_WORLD_47 },
	{ "K_WORLD_48",		QFK_WORLD_48 },
	{ "K_WORLD_49",		QFK_WORLD_49 },
	{ "K_WORLD_50",		QFK_WORLD_50 },
	{ "K_WORLD_51",		QFK_WORLD_51 },
	{ "K_WORLD_52",		QFK_WORLD_52 },
	{ "K_WORLD_53",		QFK_WORLD_53 },
	{ "K_WORLD_54",		QFK_WORLD_54 },
	{ "K_WORLD_55",		QFK_WORLD_55 },
	{ "K_WORLD_56",		QFK_WORLD_56 },
	{ "K_WORLD_57",		QFK_WORLD_57 },
	{ "K_WORLD_58",		QFK_WORLD_58 },
	{ "K_WORLD_59",		QFK_WORLD_59 },
	{ "K_WORLD_60",		QFK_WORLD_60 },
	{ "K_WORLD_61",		QFK_WORLD_61 },
	{ "K_WORLD_62",		QFK_WORLD_62 },
	{ "K_WORLD_63",		QFK_WORLD_63 },
	{ "K_WORLD_64",		QFK_WORLD_64 },
	{ "K_WORLD_65",		QFK_WORLD_65 },
	{ "K_WORLD_66",		QFK_WORLD_66 },
	{ "K_WORLD_67",		QFK_WORLD_67 },
	{ "K_WORLD_68",		QFK_WORLD_68 },
	{ "K_WORLD_69",		QFK_WORLD_69 },
	{ "K_WORLD_70",		QFK_WORLD_70 },
	{ "K_WORLD_71",		QFK_WORLD_71 },
	{ "K_WORLD_72",		QFK_WORLD_72 },
	{ "K_WORLD_73",		QFK_WORLD_73 },
	{ "K_WORLD_74",		QFK_WORLD_74 },
	{ "K_WORLD_75",		QFK_WORLD_75 },
	{ "K_WORLD_76",		QFK_WORLD_76 },
	{ "K_WORLD_77",		QFK_WORLD_77 },
	{ "K_WORLD_78",		QFK_WORLD_78 },
	{ "K_WORLD_79",		QFK_WORLD_79 },
	{ "K_WORLD_80",		QFK_WORLD_80 },
	{ "K_WORLD_81",		QFK_WORLD_81 },
	{ "K_WORLD_82",		QFK_WORLD_82 },
	{ "K_WORLD_83",		QFK_WORLD_83 },
	{ "K_WORLD_84",		QFK_WORLD_84 },
	{ "K_WORLD_85",		QFK_WORLD_85 },
	{ "K_WORLD_86",		QFK_WORLD_86 },
	{ "K_WORLD_87",		QFK_WORLD_87 },
	{ "K_WORLD_88",		QFK_WORLD_88 },
	{ "K_WORLD_89",		QFK_WORLD_89 },
	{ "K_WORLD_90",		QFK_WORLD_90 },
	{ "K_WORLD_91",		QFK_WORLD_91 },
	{ "K_WORLD_92",		QFK_WORLD_92 },
	{ "K_WORLD_93",		QFK_WORLD_93 },
	{ "K_WORLD_94",		QFK_WORLD_94 },
	{ "K_WORLD_95",		QFK_WORLD_95 },
	{ "K_KP0",			QFK_KP0 },
	{ "K_KP1",			QFK_KP1 },
	{ "K_KP2",			QFK_KP2 },
	{ "K_KP3",			QFK_KP3 },
	{ "K_KP4",			QFK_KP4 },
	{ "K_KP5",			QFK_KP5 },
	{ "K_KP6",			QFK_KP6 },
	{ "K_KP7",			QFK_KP7 },
	{ "K_KP8",			QFK_KP8 },
	{ "K_KP9",			QFK_KP9 },
	{ "K_KP_PERIOD",	QFK_KP_PERIOD },
	{ "K_KP_DIVIDE",	QFK_KP_DIVIDE },
	{ "K_KP_MULTIPLY",	QFK_KP_MULTIPLY },
	{ "K_KP_MINUS",		QFK_KP_MINUS },
	{ "K_KP_PLUS",		QFK_KP_PLUS },
	{ "K_KP_ENTER",		QFK_KP_ENTER },
	{ "K_KP_EQUALS",	QFK_KP_EQUALS },
	{ "K_UP",			QFK_UP },
	{ "K_DOWN",			QFK_DOWN },
	{ "K_RIGHT",		QFK_RIGHT },
	{ "K_LEFT",			QFK_LEFT },
	{ "K_INSERT",		QFK_INSERT },
	{ "K_HOME",			QFK_HOME },
	{ "K_END",			QFK_END },
	{ "K_PAGEUP",		QFK_PAGEUP },
	{ "K_PAGEDOWN",		QFK_PAGEDOWN },
	{ "K_F1",			QFK_F1 },
	{ "K_F2",			QFK_F2 },
	{ "K_F3",			QFK_F3 },
	{ "K_F4",			QFK_F4 },
	{ "K_F5",			QFK_F5 },
	{ "K_F6",			QFK_F6 },
	{ "K_F7",			QFK_F7 },
	{ "K_F8",			QFK_F8 },
	{ "K_F9",			QFK_F9 },
	{ "K_F10",			QFK_F10 },
	{ "K_F11",			QFK_F11 },
	{ "K_F12",			QFK_F12 },
	{ "K_F13",			QFK_F13 },
	{ "K_F14",			QFK_F14 },
	{ "K_F15",			QFK_F15 },
	{ "K_NUMLOCK",		QFK_NUMLOCK },
	{ "K_CAPSLOCK",		QFK_CAPSLOCK },
	{ "K_SCROLLOCK",	QFK_SCROLLOCK },
	{ "K_RSHIFT",		QFK_RSHIFT },
	{ "K_LSHIFT",		QFK_LSHIFT },
	{ "K_RCTRL",		QFK_RCTRL },
	{ "K_LCTRL",		QFK_LCTRL },
	{ "K_RALT",			QFK_RALT },
	{ "K_LALT",			QFK_LALT },
	{ "K_RMETA",		QFK_RMETA },
	{ "K_LMETA",		QFK_LMETA },
	{ "K_LSUPER",		QFK_LSUPER },
	{ "K_RSUPER",		QFK_RSUPER },
	{ "K_MODE",			QFK_MODE },
	{ "K_COMPOSE",		QFK_COMPOSE },
	{ "K_HELP",			QFK_HELP },
	{ "K_PRINT",		QFK_PRINT },
	{ "K_SYSREQ",		QFK_SYSREQ },
	{ "K_BREAK",		QFK_BREAK },
	{ "K_MENU",			QFK_MENU },
	{ "K_POWER",		QFK_POWER },
	{ "K_EURO",			QFK_EURO },

	{ "K_KANJI", 		QFK_KANJI },
	{ "K_MUHENKAN", 	QFK_MUHENKAN },
	{ "K_HENKAN", 		QFK_HENKAN },
	{ "K_ROMAJI", 		QFK_ROMAJI },
	{ "K_HIRAGANA", 	QFK_HIRAGANA },
	{ "K_KATAKANA", 	QFK_KATAKANA },
	{ "K_HIRAGANA_KATAKANA",	QFK_HIRAGANA_KATAKANA },
	{ "K_ZENKAKU", 		QFK_ZENKAKU },
	{ "K_HANKAKU", 		QFK_HANKAKU },
	{ "K_ZENKAKU_HANKAKU",	QFK_ZENKAKU_HANKAKU },
	{ "K_TOUROKU", 		QFK_TOUROKU },
	{ "K_MASSYO", 		QFK_MASSYO },
	{ "K_KANA_LOCK", 	QFK_KANA_LOCK },
	{ "K_KANA_SHIFT", 	QFK_KANA_SHIFT },
	{ "K_EISU_SHIFT", 	QFK_EISU_SHIFT },
	{ "K_EISU_TOGGLE", 	QFK_EISU_TOGGLE },
	{ "K_KANJI_BANGOU", QFK_KANJI_BANGOU },
	{ "K_ZEN_KOHO", 	QFK_ZEN_KOHO },
	{ "K_MAE_KOHO", 	QFK_MAE_KOHO },

	{ "K_HOMEPAGE",		QFK_HOMEPAGE },
	{ "K_SEARCH",		QFK_SEARCH },
	{ "K_MAIL",			QFK_MAIL },
	{ "K_FAVORITES",	QFK_FAVORITES },
	{ "K_AUDIOMUTE",	QFK_AUDIOMUTE },
	{ "K_AUDIOLOWERVOLUME",	QFK_AUDIOLOWERVOLUME },
	{ "K_AUDIORAISEVOLUME",	QFK_AUDIORAISEVOLUME },
	{ "K_AUDIOPLAY",		QFK_AUDIOPLAY },
	{ "K_CALCULATOR",	QFK_CALCULATOR },
	{ "K_UNDO",			QFK_UNDO },
	{ "K_REDO",			QFK_REDO },
	{ "K_NEW",			QFK_NEW },
	{ "K_RELOAD",		QFK_RELOAD },
	{ "K_OPEN",			QFK_OPEN },
	{ "K_CLOSE",		QFK_CLOSE },
	{ "K_REPLY",		QFK_REPLY },
	{ "K_MAILFORWARD",	QFK_MAILFORWARD },
	{ "K_SEND",			QFK_SEND },
	{ "K_SAVE",			QFK_SAVE },
	{ "K_BACK",			QFK_BACK },
	{ "K_FORWARD",		QFK_FORWARD },

	{ "M_BUTTON1",		QFM_BUTTON1 },
	{ "M_BUTTON2",		QFM_BUTTON2 },
	{ "M_BUTTON3",		QFM_BUTTON3 },
	{ "M_WHEEL_UP",		QFM_WHEEL_UP },
	{ "M_WHEEL_DOWN",	QFM_WHEEL_DOWN },
	{ "M_BUTTON6",		QFM_BUTTON6 },
	{ "M_BUTTON7",		QFM_BUTTON7 },
	{ "M_BUTTON8",		QFM_BUTTON8 },
	{ "M_BUTTON9",		QFM_BUTTON9 },
	{ "M_BUTTON10",		QFM_BUTTON10 },
	{ "M_BUTTON11",		QFM_BUTTON11 },
	{ "M_BUTTON12",		QFM_BUTTON12 },
	{ "M_BUTTON13",		QFM_BUTTON13 },
	{ "M_BUTTON14",		QFM_BUTTON14 },
	{ "M_BUTTON15",		QFM_BUTTON15 },
	{ "M_BUTTON16",		QFM_BUTTON16 },
	{ "M_BUTTON17",		QFM_BUTTON17 },
	{ "M_BUTTON18",		QFM_BUTTON18 },
	{ "M_BUTTON19",		QFM_BUTTON19 },
	{ "M_BUTTON20",		QFM_BUTTON20 },
	{ "M_BUTTON21",		QFM_BUTTON21 },
	{ "M_BUTTON22",		QFM_BUTTON22 },
	{ "M_BUTTON23",		QFM_BUTTON23 },
	{ "M_BUTTON24",		QFM_BUTTON24 },
	{ "M_BUTTON25",		QFM_BUTTON25 },
	{ "M_BUTTON26",		QFM_BUTTON26 },
	{ "M_BUTTON27",		QFM_BUTTON27 },
	{ "M_BUTTON28",		QFM_BUTTON28 },
	{ "M_BUTTON29",		QFM_BUTTON29 },
	{ "M_BUTTON30",		QFM_BUTTON30 },
	{ "M_BUTTON31",		QFM_BUTTON31 },
	{ "M_BUTTON32",		QFM_BUTTON32 },

	{ "J_BUTTON1",		QFJ_BUTTON1 },
	{ "J_BUTTON2",		QFJ_BUTTON2 },
	{ "J_BUTTON3",		QFJ_BUTTON3 },
	{ "J_BUTTON4",		QFJ_BUTTON4 },
	{ "J_BUTTON5",		QFJ_BUTTON5 },
	{ "J_BUTTON6",		QFJ_BUTTON6 },
	{ "J_BUTTON7",		QFJ_BUTTON7 },
	{ "J_BUTTON8",		QFJ_BUTTON8 },
	{ "J_BUTTON9",		QFJ_BUTTON9 },
	{ "J_BUTTON10",		QFJ_BUTTON10 },
	{ "J_BUTTON11",		QFJ_BUTTON11 },
	{ "J_BUTTON12",		QFJ_BUTTON12 },
	{ "J_BUTTON13",		QFJ_BUTTON13 },
	{ "J_BUTTON14",		QFJ_BUTTON14 },
	{ "J_BUTTON15",		QFJ_BUTTON15 },
	{ "J_BUTTON16",		QFJ_BUTTON16 },
	{ "J_BUTTON17",		QFJ_BUTTON17 },
	{ "J_BUTTON18",		QFJ_BUTTON18 },
	{ "J_BUTTON19",		QFJ_BUTTON19 },
	{ "J_BUTTON20",		QFJ_BUTTON20 },
	{ "J_BUTTON21",		QFJ_BUTTON21 },
	{ "J_BUTTON22",		QFJ_BUTTON22 },
	{ "J_BUTTON23",		QFJ_BUTTON23 },
	{ "J_BUTTON24",		QFJ_BUTTON24 },
	{ "J_BUTTON25",		QFJ_BUTTON25 },
	{ "J_BUTTON26",		QFJ_BUTTON26 },
	{ "J_BUTTON27",		QFJ_BUTTON27 },
	{ "J_BUTTON28",		QFJ_BUTTON28 },
	{ "J_BUTTON29",		QFJ_BUTTON29 },
	{ "J_BUTTON30",		QFJ_BUTTON30 },
	{ "J_BUTTON31",		QFJ_BUTTON31 },
	{ "J_BUTTON32",		QFJ_BUTTON32 },

	{ "J_AXIS1",		QFJ_AXIS1 },
	{ "J_AXIS2",		QFJ_AXIS2 },
	{ "J_AXIS3",		QFJ_AXIS3 },
	{ "J_AXIS4",		QFJ_AXIS4 },
	{ "J_AXIS5",		QFJ_AXIS5 },
	{ "J_AXIS6",		QFJ_AXIS6 },
	{ "J_AXIS7",		QFJ_AXIS7 },
	{ "J_AXIS8",		QFJ_AXIS8 },
	{ "J_AXIS9",		QFJ_AXIS9 },
	{ "J_AXIS10",		QFJ_AXIS10 },
	{ "J_AXIS11",		QFJ_AXIS11 },
	{ "J_AXIS12",		QFJ_AXIS12 },
	{ "J_AXIS13",		QFJ_AXIS13 },
	{ "J_AXIS14",		QFJ_AXIS14 },
	{ "J_AXIS15",		QFJ_AXIS15 },
	{ "J_AXIS16",		QFJ_AXIS16 },
	{ "J_AXIS17",		QFJ_AXIS17 },
	{ "J_AXIS18",		QFJ_AXIS18 },
	{ "J_AXIS19",		QFJ_AXIS19 },
	{ "J_AXIS20",		QFJ_AXIS20 },
	{ "J_AXIS21",		QFJ_AXIS21 },
	{ "J_AXIS22",		QFJ_AXIS22 },
	{ "J_AXIS23",		QFJ_AXIS23 },
	{ "J_AXIS24",		QFJ_AXIS24 },
	{ "J_AXIS25",		QFJ_AXIS25 },
	{ "J_AXIS26",		QFJ_AXIS26 },
	{ "J_AXIS27",		QFJ_AXIS27 },
	{ "J_AXIS28",		QFJ_AXIS28 },
	{ "J_AXIS29",		QFJ_AXIS29 },
	{ "J_AXIS30",		QFJ_AXIS30 },
	{ "J_AXIS31",		QFJ_AXIS31 },
	{ "J_AXIS32",		QFJ_AXIS32 },

	{NULL, 0}
};

static imt_t *
key_target_find_imt (keytarget_t *kt, const char *imt_name)
{
	imt_t      *imt;
	for (imt = kt->imts; imt; imt = imt->next) {
		if (!strcasecmp (imt->name, imt_name)) {
			return imt;
		}
	}
	return 0;
}

VISIBLE imt_t *
Key_FindIMT (const char *imt_name)
{
	keydest_t   kd;
	imt_t      *imt = 0;

	for (kd = key_unfocused; !imt && kd < key_last; kd++) {
		imt = key_target_find_imt (&key_targets[kd], imt_name);
	}
	return imt;
}

void
Key_CreateIMT (keydest_t kd, const char *imt_name, const char *chain_imt_name)
{
	imt_t      *imt;
	imt_t      *chain_imt = 0;
	keytarget_t *kt = &key_targets[kd];

	imt = Key_FindIMT (imt_name);
	if (imt) {
		Sys_Printf ("imt error: imt %s already exists\n", imt_name);
		return;
	}
	if (chain_imt_name) {
		chain_imt = Key_FindIMT (chain_imt_name);
		if (!chain_imt) {
			Sys_Printf ("imt error: chain imt %s does not exist\n",
						chain_imt_name);
			return;
		}
		imt = key_target_find_imt (kt, chain_imt_name);
		if (!imt) {
			Sys_Printf ("imt error: chain imt %s not on target key "
						"destination\n", chain_imt_name);
			return;
		}
	}
	imt = calloc (1, sizeof (imt_t));
	imt->name = strdup (imt_name);
	imt->chain = chain_imt;
	imt->next = kt->imts;
	kt->imts = imt;
	if (!kt->active) {
		kt->active = imt;
	}
}

VISIBLE void
Key_SetBinding (imt_t *imt, knum_t keynum, const char *binding)
{
	if (keynum == (knum_t) -1)
		return;

	if (imt->bindings[keynum].str) {
		free (imt->bindings[keynum].str);
		imt->bindings[keynum].str = NULL;
	}
	if (binding) {
		imt->bindings[keynum].str = strdup(binding);
	}
}

static void
Key_CallDestCallbacks (keydest_t kd)
{
	int         i;

	for (i = 0; i < num_keydest_callbacks; i++)
		keydest_callbacks[i] (kd);
}

static void
process_binding (knum_t key, const char *kb)
{
	char        cmd[1024];

	if (kb[0] == '+') {
		if (keydown[key])
			snprintf (cmd, sizeof (cmd), "%s %d\n", kb, key);
		else
			snprintf (cmd, sizeof (cmd), "-%s %d\n", kb + 1, key);
	} else {
		if (!keydown[key])
			return;
		snprintf (cmd, sizeof (cmd), "%s\n", kb);
	}
	Cbuf_AddText (cbuf, cmd);
}

/*
  Key_Game

  Game key handling.
*/
static qboolean
Key_Game (knum_t key, short unicode)
{
	const char *kb;
	imt_t      *imt = key_targets[key_dest].active;

	while (imt) {
		kb = imt->bindings[key].str;
		if (kb) {
			if (keydown[key] <= 1)
				process_binding (key, kb);
			return true;
		}
		imt = imt->chain;
	}
	return false;
/*
	Sys_DPrintf("kb %p, key_target %d, key_dest %d, key %d\n", kb,
				key_target, key_dest, key);
*/
}

/*
  Key_Console

  Interactive line editing and console scrollback
*/
static void
Key_Console (knum_t key, short unicode)
{
	// escape is un-bindable
	if (keydown[key] == 1 && key && Key_Game (key, unicode))
		return;

	Con_KeyEvent (key, unicode, keydown[key]);
}

//============================================================================

/*
  Key_StringToKeynum

  Returns a key number to be used to index keybindings[] by looking at
  the given string.  Single ascii characters return themselves, while
  the QFK_* names are matched up.
*/
VISIBLE int
Key_StringToKeynum (const char *str)
{
	keyname_t  *kn;

	if (!str || !str[0])
		return -1;

	for (kn = keynames; kn->name; kn++) {
		if (!strcasecmp (str, kn->name))
			return kn->keynum;
	}
	return -1;
}

/*
  Key_KeynumToString

  Returns a string (a QFK_* name) for the given keynum.
  FIXME: handle quote special (general escape sequence?)
*/
VISIBLE const char *
Key_KeynumToString (knum_t keynum)
{
	keyname_t  *kn;

	if (keynum == (knum_t) -1)
		return "<KEY NOT FOUND>";

	for (kn = keynames; kn->name; kn++)
		if (keynum == kn->keynum)
			return kn->name;

	return "<UNKNOWN KEYNUM>";
}

static void
Key_In_Unbind (const char *imt_name, const char *key_name)
{
	imt_t      *imt;
	int         key;

	imt = Key_FindIMT (imt_name);
	if (!imt) {
		Sys_Printf ("\"%s\" isn't a valid imt\n", imt_name);
		return;
	}

	key = Key_StringToKeynum (key_name);
	if (key == -1) {
		Sys_Printf ("\"%s\" isn't a valid key\n", key_name);
		return;
	}

	Key_SetBinding (imt, key, NULL);
}

static void
Key_In_Unbind_f (void)
{
	if (Cmd_Argc () != 3) {
		Sys_Printf ("in_unbind <imt> <key> : remove commands from a key\n");
		return;
	}
	Key_In_Unbind (Cmd_Argv (1), Cmd_Argv (2));
}

static void
Key_Unbindall_f (void)
{
	keydest_t   kd;
	imt_t      *imt;
	int         i;

	for (kd = key_unfocused; kd < key_last; kd++) {
		for (imt = key_targets[kd].imts; imt; imt = imt->next) {
			for (i = 0; i < QFK_LAST; i++) {
				Key_SetBinding (imt, i, 0);
			}
		}
	}
}

static void
Key_In_Type_f (void)
{
	const char *str, *p;
	if (Cmd_Argc () != 2) {
		Sys_Printf ("in_type <string>\n");
		Sys_Printf ("    Send the given string as simulated key presses.\n");
		return;
	}
	str = Cmd_Argv (1);
	for (p = str; *p; p++) {
		Key_Event (QFK_UNKNOWN, *p, 1);
		Key_Event (QFK_UNKNOWN, 0, 0);
	}
}

static void
Key_In_Clear (void)
{
	int         err = 0;
	imt_t      *imt;
	int         i, j;

	if (Cmd_Argc () == 1) {
		Sys_Printf ("in_clear <imt> ...\n");
		return;
	}
	for (i = 1; i < Cmd_Argc (); i++) {
		if (!Key_FindIMT (Cmd_Argv (i))) {
			Sys_Printf ("\"%s\" isn't a valid imt\n", Cmd_Argv (i));
			err = 1;
		}
	}
	if (err)
		return;
	for (i = 1; i < Cmd_Argc (); i++) {
		imt = Key_FindIMT (Cmd_Argv (i));
		for (j = 0; j < QFK_LAST; j++)
			Key_SetBinding (imt, j, NULL);
	}
}

static void
Key_IMT_Create_f (void)
{
	const char *keydest;
	const char *imt_name;
	const char *chain_imt_name = 0;
	keydest_t   kd;

	if (Cmd_Argc () < 3 || Cmd_Argc () > 4) {
		Sys_Printf ("see help imt_create\n");
		return;
	}
	keydest = Cmd_Argv (1);
	imt_name = Cmd_Argv (2);
	if (Cmd_Argc () == 4) {
		chain_imt_name = Cmd_Argv (3);
	}
	for (kd = key_game; kd < key_last; kd++) {
		if (!strcasecmp (keydest_names[kd], keydest)) {
			break;
		}
	}
	if (kd == key_last) {
		Sys_Printf ("imt error: invalid keydest: %s\n", keydest);
		return;
	}
	Key_CreateIMT (kd, imt_name, chain_imt_name);
}

static void
Key_IMT_Drop_All_f (void)
{
	keydest_t   kd;
	imt_t       *imt;

	for (kd = key_unfocused; kd < key_last; kd++) {
		while (key_targets[kd].imts) {
			imt = key_targets[kd].imts;
			key_targets[kd].imts = imt->next;
			free ((char *) imt->name);
			free (imt);
		}
		key_targets[kd].active = 0;
	}
}

static void
Key_In_Bind (const char *imt_name, const char *key_name, const char *cmd)
{
	imt_t      *imt;
	int         key;

	imt = Key_FindIMT (imt_name);
	if (!imt) {
		Sys_Printf ("\"%s\" isn't a valid imt\n", imt_name);
		return;
	}

	key = Key_StringToKeynum (key_name);
	if (key == -1) {
		Sys_Printf ("\"%s\" isn't a valid key\n", key_name);
		return;
	}

	if (!cmd) {
		if (imt->bindings[key].str)
			Sys_Printf ("%s %s \"%s\"\n", imt_name, key_name,
						imt->bindings[key].str);
		else
			Sys_Printf ("%s %s is not bound\n", imt_name, key_name);
		return;
	}
	Key_SetBinding (imt, key, cmd);
}

static void
Key_In_Bind_f (void)
{
	int         c, i;
	const char *imt, *key, *cmd = 0;
	char        cmd_buf[1024];

	c = Cmd_Argc ();

	if (c < 3) {
		Sys_Printf ("in_bind <imt> <key> [command] : attach a command to a "
					"key\n");
		return;
	}

	imt = Cmd_Argv (1);

	key = Cmd_Argv (2);

	if (c >= 4) {
		cmd = cmd_buf;
		cmd_buf[0] = 0;
		for (i = 3; i < c; i++) {
			strncat (cmd_buf, Cmd_Argv (i), sizeof (cmd_buf) -
					 strlen (cmd_buf));
			if (i != (c - 1))
				strncat (cmd_buf, " ", sizeof (cmd_buf) - strlen (cmd_buf));
		}
	}

	Key_In_Bind (imt, key, cmd);
}

static void
Key_Unbind_f (void)
{
	const char *key;

	if (Cmd_Argc () != 2) {
		Sys_Printf ("unbind <key> : remove commands from a key\n");
		return;
	}
	key = OK_TranslateKeyName (Cmd_Argv (1));
	Key_In_Unbind ("imt_mod", key);
}

static void
Key_Bind_f (void)
{
	int         c, i;
	const char *key, *cmd = 0;
	char        cmd_buf[1024];

	c = Cmd_Argc ();

	if (c < 2) {
		Sys_Printf ("bind <key> [command] : attach a command to a key\n");
		return;
	}

	key = OK_TranslateKeyName (Cmd_Argv (1));

	if (c >= 3) {
		cmd = cmd_buf;
		cmd_buf[0] = 0;
		for (i = 2; i < c; i++) {
			strncat (cmd_buf, Cmd_Argv (i), sizeof (cmd_buf) -
					 strlen (cmd_buf));
			if (i != (c - 1))
				strncat (cmd_buf, " ", sizeof (cmd_buf) - strlen (cmd_buf));
		}
	}

	Key_In_Bind ("imt_mod", key, cmd);
}

static void
Key_GIB_Bind_Get_f (void)
{
	const char *key, *cmd;
	int k;

	if (GIB_Argc () != 2) {
		GIB_USAGE ("key");
		return;
	}

	key = OK_TranslateKeyName (GIB_Argv (1));

	if ((k = Key_StringToKeynum (key)) == -1) {
		GIB_Error ("bind", "bind::get: invalid key %s", key);
		return;
	}

	if (!(cmd = Key_GetBinding ("IMT_MOD", k)))
		GIB_Return ("");
	else
		GIB_Return (cmd);
}

static void
in_key_togglemenu_f (cvar_t *var)
{
	int         k;

	if (!*var->string) {
		key_togglemenu = QFK_ESCAPE;
		return;
	}
	if ((k = Key_StringToKeynum (var->string)) == -1) {
		k = QFK_ESCAPE;
		Sys_Printf ("\"%s\" is not a valid key. setting to \"K_ESCAPE\"\n",
					var->string);
	}
	key_togglemenu = k;
}

static void
in_key_toggleconsole_f (cvar_t *var)
{
	int         k;

	if (!*var->string) {
		key_toggleconsole = -1;
		return;
	}
	if ((k = Key_StringToKeynum (var->string)) == -1) {
		Sys_Printf ("\"%s\" is not a valid key. not setting\n",
					var->string);
		return;
	}
	key_toggleconsole = k;
}

static void
Key_InputMappingTable_f (void)
{
	int         c;
	imt_t      *imt;

	c = Cmd_Argc ();

	if (c != 2) {
		Sys_Printf ("Current imt is %s\n", key_targets[key_game].active->name);
		Sys_Printf ("imt <imt> : set to a specific input mapping table\n");
		return;
	}

	imt = Key_FindIMT (Cmd_Argv (1));
	if (!imt) {
		Sys_Printf ("\"%s\" isn't a valid imt\n", Cmd_Argv (1));
		return;
	}

	key_targets[key_game].active = imt;
}

static void
Key_IMT_Keydest_f (void)
{
	int         c;
	imt_t      *imt;
	const char *imt_name = 0;
	const char *keydest;
	keydest_t   kd;

	c = Cmd_Argc ();
	switch (c) {
		case 3:
			imt_name = Cmd_Argv (2);
		case 2:
			keydest = Cmd_Argv (1);
			break;
		default:
			return;
	}
	for (kd = key_game; kd < key_last; kd++) {
		if (!strcasecmp (keydest_names[kd], keydest)) {
			break;
		}
	}
	if (kd == key_last) {
		Sys_Printf ("imt error: invalid keydest: %s\n", keydest);
		return;
	}

	if (!imt_name) {
		Sys_Printf ("Current imt is %s\n", key_targets[key_game].active->name);
		Sys_Printf ("imt <imt> : set to a specific input mapping table\n");
		return;
	}

	imt = key_target_find_imt (&key_targets[kd], imt_name);
	if (!imt) {
		Sys_Printf ("\"%s\" isn't an imt on %s\n", imt_name, keydest);
		return;
	}

	key_targets[kd].active = imt;
}

static void __attribute__((format(printf,2,3)))
key_printf (QFile *f, const char *fmt, ...)
{
	va_list     args;
	static dstring_t *string;

	if (!string) {
		string = dstring_new ();
	}
	va_start (args, fmt);
	dvsprintf (string, fmt, args);
	va_end (args);

	if (f) {
		Qprintf (f, "%s", string->str);
	} else {
		Sys_Printf ("%s", string->str);
	}
}

static void
key_write_imt (QFile *f, keydest_t kd, imt_t *imt)
{
	int         i;
	const char *bind;

	if (!imt || imt->written) {
		return;
	}
	imt->written = 1;
	key_write_imt (f, kd, imt->chain);
	if (imt->chain) {
		key_printf (f, "imt_create %s %s %s\n", keydest_names[kd],
					imt->name, imt->chain->name);
	} else {
		key_printf (f, "imt_create %s %s\n", keydest_names[kd], imt->name);
	}
	for (i = 0; i < QFK_LAST; i++) {
		bind = imt->bindings[i].str;
		if (bind) {
			key_printf (f, "in_bind %s %s \"%s\"\n", imt->name,
						Key_KeynumToString (i), bind);
		}
	}
}

void
Key_WriteBindings (QFile *f)
{
	keydest_t   kd;
	imt_t      *imt;

	for (kd = key_unfocused; kd < key_last; kd++) {
		for (imt = key_targets[kd].imts; imt; imt = imt->next) {
			imt->written = 0;
		}
	}
	key_printf (f, "imt_drop_all\n");
	for (kd = key_unfocused; kd < key_last; kd++) {
		if (key_targets[kd].imts) {
			for (imt = key_targets[kd].imts; imt; imt = imt->next) {
				key_write_imt (f, kd, imt);
			}
			key_printf (f, "imt_keydest %s %s\n", keydest_names[kd],
						key_targets[kd].active->name);
		}
	}
}

static void
Key_Bindlist_f (void)
{
	Key_WriteBindings (0);
}

static void
keyhelp_f (void)
{
	keyhelp = 1;
}

/*
  Key_Event

  Called by the system between frames for both key up and key down events
  Should NOT be called during an interrupt!
*/
VISIBLE void
Key_Event (knum_t key, short unicode, qboolean down)
{
//  Sys_Printf ("%d %d %d : %d\n", key_target, key_dest, key, down); //@@@

	if (down) {
		keydown[key]++;
		if (keyhelp) {
			Sys_Printf ("Key name for that key is \"%s\"\n",
						Key_KeynumToString (key));
			keyhelp = 0;
			return; // gobble the key
		}
	} else {
		keydown[key] = 0;
	}

	// handle escape specially, so the user can never unbind it
	if (key == key_togglemenu || key == key_toggleconsole) {
		Key_Console (key, unicode);
		return;
	}

	if (!down && Key_Game (key, unicode))
		return;

	// if not a consolekey, send to the interpreter no matter what mode is
	switch (key_dest) {
		case key_game:
		case key_demo:
			Key_Game (key, unicode);
			return;
		case key_message:
		case key_menu:
		case key_console:
			Key_Console (key, unicode);
			return;
		case key_unfocused:
			return;
		case key_last:
			break;	// should not happen, so hit the error
	}
	Sys_Error ("Bad key_dest");
}

VISIBLE void
Key_FocusEvent (int gain)
{
	if (gain) {
		Key_CallDestCallbacks (key_dest);
	} else {
		Key_CallDestCallbacks (key_unfocused);
	}
}

void
Key_ClearStates (void)
{
	int         i;

	for (i = 0; i < QFK_LAST; i++) {
		if (keydown[i])
			Key_Event (i, 0, false);
		keydown[i] = false;
	}
}

static struct {
	keydest_t   kd;
	const char *imt_name;
	const char *chain_imt_name;
} default_imts[] = {
	{key_game,		"imt_mod",		0},
	{key_game,		"imt_0",		"imt_mod"},
	{key_game,		"imt_1",		"imt_0"},
	{key_game,		"imt_2",		"imt_0"},
	{key_game,		"imt_3",		"imt_0"},
	{key_game,		"imt_4",		"imt_0"},
	{key_game,		"imt_5",		"imt_0"},
	{key_game,		"imt_6",		"imt_0"},
	{key_game,		"imt_7",		"imt_0"},
	{key_game,		"imt_8",		"imt_0"},
	{key_game,		"imt_9",		"imt_0"},
	{key_game,		"imt_10",		"imt_0"},
	{key_game,		"imt_11",		"imt_0"},
	{key_game,		"imt_12",		"imt_0"},
	{key_game,		"imt_13",		"imt_0"},
	{key_game,		"imt_14",		"imt_0"},
	{key_game,		"imt_15",		"imt_0"},
	{key_game,		"imt_16",		"imt_0"},
	{key_demo,		"imt_demo",		0},
	{key_console,	"imt_console",	0},
	{key_message,	"imt_message",	0},
	{key_menu,		"imt_menu",		0},
	{key_last,		0,				0},
};

static void
Key_CreateDefaultIMTs (void)
{
	int         i;

	for (i = 0; default_imts[i].kd != key_last; i++) {
		Key_CreateIMT (default_imts[i].kd, default_imts[i].imt_name,
					   default_imts[i].chain_imt_name);
	}
}

void
Key_Init (cbuf_t *cb)
{
	cbuf = cb;

	Key_CreateDefaultIMTs ();

	OK_Init ();

	// register our functions
	Cmd_AddCommand ("in_bind", Key_In_Bind_f, "Assign a command or a set of "
					"commands to a key.\n"
					"Note: To bind multiple commands to a key, enclose the "
					"commands in quotes and separate with semi-colons.");
	Cmd_AddCommand ("in_unbind", Key_In_Unbind_f,
					"Remove the bind from the the selected key");
	Cmd_AddCommand ("unbindall", Key_Unbindall_f,
					"Remove all binds (USE CAUTIOUSLY!!!)");
	Cmd_AddCommand ("in_clear", Key_In_Clear,
					"Remove all binds from the specified imts");
	Cmd_AddCommand ("in_type", Key_In_Type_f,
					"Send the given string as simulated key presses.");
	Cmd_AddCommand ("imt", Key_InputMappingTable_f, "");
	Cmd_AddCommand ("imt_keydest", Key_IMT_Keydest_f, "");
	Cmd_AddCommand ("imt_create", Key_IMT_Create_f,
					"create a new imt table:\n"
					"    imt_create <keydest> <imt_name> [chain_name]\n"
					"\n"
					"The new table will be attached to the specified keydest\n"
					"imt_name must not already exist.\n"
					"If given, chain_name must already exist and be on "
						"keydest.\n");
	Cmd_AddCommand ("imt_drop_all", Key_IMT_Drop_All_f,
					"delete all imt tables\n");
	Cmd_AddCommand ("bind", Key_Bind_f, "wrapper for in_bind that uses "
					"in_bind_imt for the imt parameter");
	Cmd_AddCommand ("unbind", Key_Unbind_f,
					"wrapper for in_unbind that uses in_bind_imt for the imt "
					"parameter");
	Cmd_AddCommand ("bindlist", Key_Bindlist_f, "list all of the key bindings");
	Cmd_AddCommand ("keyhelp", keyhelp_f, "display the keyname for the next "
					"RECOGNIZED key-press. If the key pressed produces no "
					"output, " PACKAGE_NAME " does not recognise that key.");

	GIB_Builtin_Add ("bind::get", Key_GIB_Bind_Get_f);

}

void
Key_Init_Cvars (void)
{
	Cvar_Get ("in_key_togglemenu", "", CVAR_NONE, in_key_togglemenu_f,
			  "Key for toggling the menu.");
	Cvar_Get ("in_key_toggleconsole", "K_BACKQUOTE", CVAR_NONE,
			  in_key_toggleconsole_f,
			  "Key for toggling the console.");
}

const char *
Key_GetBinding (const char *imt_name, knum_t key)
{
	imt_t      *imt;

	imt = Key_FindIMT (imt_name);
	if (imt) {
		return imt->bindings[key].str;
	}
	return 0;
}

VISIBLE void
Key_SetKeyDest(keydest_t kd)
{
	if ((int) kd < key_unfocused || kd >= key_last) {
		Sys_Error ("Bad key_dest");
	}
	key_dest = kd;
	Key_CallDestCallbacks (key_dest);
}

VISIBLE void
Key_KeydestCallback (keydest_callback_t *callback)
{
	if (num_keydest_callbacks == max_keydest_callbacks) {
		size_t size = (max_keydest_callbacks + KEYDEST_CALLBACK_CHUNK)
					  * sizeof (keydest_callback_t *);
		keydest_callbacks = realloc (keydest_callbacks, size);
		if (!keydest_callbacks)
			Sys_Error ("Too many keydest callbacks!");
		max_keydest_callbacks += KEYDEST_CALLBACK_CHUNK;
	}

	if (!callback)
		Sys_Error ("null keydest callback");

	keydest_callbacks[num_keydest_callbacks++] = callback;
}