src/console.c

@@ -906,6 +906,7 @@ boolean CON_Responder(event_t *ev)
 
 	const char *cmd = NULL;
 	INT32 key;
+	INT32 realkey;
 
 	if (chat_on)
 		return false;
@@ -919,6 +920,7 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	key = ev->key;
+	realkey = ev->realkey;
 
 	// check for console toggle key
 	if (ev->type != ev_console)
@@ -956,12 +958,12 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// Always eat ctrl/shift/alt if console open, so the menu doesn't get ideas
-	if (key == KEY_LSHIFT || key == KEY_RSHIFT
-	 || key == KEY_LCTRL || key == KEY_RCTRL
-	 || key == KEY_LALT || key == KEY_RALT)
+	if (realkey == KEY_LSHIFT || realkey == KEY_RSHIFT
+	 || realkey == KEY_LCTRL || realkey == KEY_RCTRL
+	 || realkey == KEY_LALT || realkey == KEY_RALT)
 		return true;
 
-	if (key == KEY_LEFTARROW)
+	if (realkey == KEY_LEFTARROW)
 	{
 		if (input_cur != 0)
 		{
@@ -974,7 +976,7 @@ boolean CON_Responder(event_t *ev)
 			input_sel = input_cur;
 		return true;
 	}
-	else if (key == KEY_RIGHTARROW)
+	else if (realkey == KEY_RIGHTARROW)
 	{
 		if (input_cur < input_len)
 		{
@@ -991,13 +993,13 @@ boolean CON_Responder(event_t *ev)
 	// backspace and delete command prompt
 	if (input_sel != input_cur)
 	{
-		if (key == KEY_BACKSPACE || key == KEY_DEL)
+		if (realkey == KEY_BACKSPACE || realkey == KEY_DEL)
 		{
 			CON_InputDelSelection();
 			return true;
 		}
 	}
-	else if (key == KEY_BACKSPACE)
+	else if (realkey == KEY_BACKSPACE)
 	{
 		if (ctrldown)
 		{
@@ -1008,7 +1010,7 @@ boolean CON_Responder(event_t *ev)
 			CON_InputDelChar();
 		return true;
 	}
-	else if (key == KEY_DEL)
+	else if (realkey == KEY_DEL)
 	{
 		if (input_cur == input_len)
 			return true;
@@ -1030,7 +1032,7 @@ boolean CON_Responder(event_t *ev)
 	if (ctrldown)
 	{
 		// show all cvars/commands that match what we have inputted
-		if (key == KEY_TAB)
+		if (realkey == KEY_TAB)
 		{
 			size_t i, len;
 
@@ -1066,18 +1068,18 @@ boolean CON_Responder(event_t *ev)
 		}
 		// ---
 
-		if (key == KEY_HOME) // oldest text in buffer
+		if (realkey == KEY_HOME) // oldest text in buffer
 		{
 			con_scrollup = (con_totallines-((con_curlines-16)>>3));
 			return true;
 		}
-		else if (key == KEY_END) // most recent text in buffer
+		else if (realkey == KEY_END) // most recent text in buffer
 		{
 			con_scrollup = 0;
 			return true;
 		}
 
-		if (key == 'x' || key == 'X')
+		if (realkey == 'x' || realkey == 'X')
 		{
 			if (input_sel > input_cur)
 				I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
@@ -1087,7 +1089,7 @@ boolean CON_Responder(event_t *ev)
 			completion[0] = 0;
 			return true;
 		}
-		else if (key == 'c' || key == 'C')
+		else if (realkey == 'c' || realkey == 'C')
 		{
 			if (input_sel > input_cur)
 				I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
@@ -1095,7 +1097,7 @@ boolean CON_Responder(event_t *ev)
 				I_ClipboardCopy(&inputlines[inputline][input_sel], input_cur-input_sel);
 			return true;
 		}
-		else if (key == 'v' || key == 'V')
+		else if (realkey == 'v' || realkey == 'V')
 		{
 			const char *paste = I_ClipboardPaste();
 			if (input_sel != input_cur)
@@ -1107,7 +1109,7 @@ boolean CON_Responder(event_t *ev)
 		}
 
 		// Select all
-		if (key == 'a' || key == 'A')
+		if (realkey == 'a' || realkey == 'A')
 		{
 			input_sel = 0;
 			input_cur = input_len;
@@ -1120,7 +1122,7 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// command completion forward (tab) and backward (shift-tab)
-	if (key == KEY_TAB)
+	if (realkey == KEY_TAB)
 	{
 		// sequential command completion forward and backward
 
@@ -1194,26 +1196,26 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// move up (backward) in console textbuffer
-	if (key == KEY_PGUP)
+	if (realkey == KEY_PGUP)
 	{
 		if (con_scrollup < (con_totallines-((con_curlines-16)>>3)))
 			con_scrollup++;
 		return true;
 	}
-	else if (key == KEY_PGDN)
+	else if (realkey == KEY_PGDN)
 	{
 		if (con_scrollup > 0)
 			con_scrollup--;
 		return true;
 	}
-	else if (key == KEY_HOME)
+	else if (realkey == KEY_HOME)
 	{
 		input_cur = 0;
 		if (!shiftdown)
 			input_sel = input_cur;
 		return true;
 	}
-	else if (key == KEY_END)
+	else if (realkey == KEY_END)
 	{
 		input_cur = input_len;
 		if (!shiftdown)
@@ -1226,7 +1228,7 @@ boolean CON_Responder(event_t *ev)
 	completion[0] = 0;
 
 	// command enter
-	if (key == KEY_ENTER)
+	if (realkey == KEY_ENTER)
 	{
 		if (!input_len)
 			return true;
@@ -1245,7 +1247,7 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// move back in input history
-	if (key == KEY_UPARROW)
+	if (realkey == KEY_UPARROW)
 	{
 		// copy one of the previous inputlines to the current
 		do
@@ -1262,7 +1264,7 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// move forward in input history
-	if (key == KEY_DOWNARROW)
+	if (realkey == KEY_DOWNARROW)
 	{
 		if (inputhist == inputline)
 			return true;
@@ -1279,33 +1281,33 @@ boolean CON_Responder(event_t *ev)
 	}
 
 	// allow people to use keypad in console (good for typing IP addresses) - Calum
-	if (key >= KEY_KEYPAD7 && key <= KEY_KPADDEL)
+	if (realkey >= KEY_KEYPAD7 && realkey <= KEY_KPADDEL)
 	{
 		char keypad_translation[] = {'7','8','9','-',
 		                             '4','5','6','+',
 		                             '1','2','3',
 		                             '0','.'};
 
-		key = keypad_translation[key - KEY_KEYPAD7];
+		realkey = keypad_translation[realkey - KEY_KEYPAD7];
 	}
-	else if (key == KEY_KPADSLASH)
-		key = '/';
+	else if (realkey == KEY_KPADSLASH)
+		realkey = '/';
 
-	if (key >= 'a' && key <= 'z')
+	if (realkey >= 'a' && realkey <= 'z')
 	{
 		if (capslock ^ shiftdown)
-			key = shiftxform[key];
+			realkey = shiftxform[key];
 	}
 	else if (shiftdown)
-		key = shiftxform[key];
+		realkey = shiftxform[key];
 
 	// enter a char into the command prompt
-	if (key < 32 || key > 127)
+	if (realkey < 32 || realkey > 127)
 		return true;
 
 	if (input_sel != input_cur)
 		CON_InputDelSelection();
-	CON_InputAddChar(key);
+	CON_InputAddChar(realkey);
 
 	return true;
 }

src/d_event.h

@@ -34,6 +34,7 @@ typedef struct
 {
 	evtype_t type;
 	INT32 key; // keys/mouse/joystick buttons
+	INT32 realkey; // key according to keyboard layout
 	INT32 x; // mouse/joystick x move
 	INT32 y; // mouse/joystick y move
 	boolean repeated; // key repeat

src/d_main.c

@@ -136,6 +136,8 @@ boolean usehome = true;
 const char *pandf = "%s" PATHSEP "%s";
 static char addonsdir[MAX_WADPATH];
 
+consvar_t cv_kb_ignorelayout = CVAR_INIT ("kb_ignorelayout", "Off", CV_SAVE, CV_OnOff, NULL);
+
 //
 // EVENT HANDLING
 //
@@ -187,6 +189,10 @@ void D_ProcessEvents(void)
 
 		ev = &events[eventtail];
 
+		// Use scancode key instead of keycode key to ignore layout.
+		if (cv_kb_ignorelayout.value)
+			ev->realkey = ev->key;
+
 		// Set mouse buttons early in case event is eaten later
 		if (ev->type == ev_keydown || ev->type == ev_keyup)
 		{

src/d_main.h

@@ -27,6 +27,8 @@ extern boolean usehome; //Alam: which path?
 extern const char *pandf; //Alam: how to path?
 extern char srb2path[256]; //Alam: SRB2's Home
 
+extern consvar_t cv_kb_ignorelayout;
+
 // the infinite loop of D_SRB2Loop() called from win_main for windows version
 void D_SRB2Loop(void) FUNCNORETURN;
 

src/d_netcmd.c

@@ -761,6 +761,9 @@ void D_RegisterClientCommands(void)
 	CV_RegisterVar(&cv_showfocuslost);
 	CV_RegisterVar(&cv_pauseifunfocused);
 
+	// d_main.c
+	CV_RegisterVar(&cv_kb_ignorelayout);
+
 	// g_input.c
 	CV_RegisterVar(&cv_sideaxis);
 	CV_RegisterVar(&cv_sideaxis2);

src/hu_stuff.c

@@ -1125,7 +1125,7 @@ boolean HU_Responder(event_t *ev)
 	}*/	//We don't actually care about that unless we get splitscreen netgames. :V
 
 #ifndef NONET
-	c = (INT32)ev->key;
+	c = (INT32)ev->realkey;
 
 	if (!chat_on)
 	{
@@ -1157,12 +1157,12 @@ boolean HU_Responder(event_t *ev)
 		// Ignore modifier keys
 		// Note that we do this here so users can still set
 		// their chat keys to one of these, if they so desire.
-		if (ev->key == KEY_LSHIFT || ev->key == KEY_RSHIFT
-		 || ev->key == KEY_LCTRL || ev->key == KEY_RCTRL
-		 || ev->key == KEY_LALT || ev->key == KEY_RALT)
+		if (ev->realkey == KEY_LSHIFT || ev->realkey == KEY_RSHIFT
+		 || ev->realkey == KEY_LCTRL || ev->realkey == KEY_RCTRL
+		 || ev->realkey == KEY_LALT || ev->realkey == KEY_RALT)
 			return true;
 
-		c = (INT32)ev->key;
+		c = (INT32)ev->realkey;
 
 		// I know this looks very messy but this works. If it ain't broke, don't fix it!
 		// shift LETTERS to uppercase if we have capslock or are holding shift

src/lua_inputlib.c

@@ -189,6 +189,10 @@ static int keyevent_get(lua_State *L)
 		lua_pushstring(L, G_KeyNumToName(event->key));
 	else if (fastcmp(field,"num"))
 		lua_pushinteger(L, event->key);
+	else if (fastcmp(field,"realname"))
+		lua_pushstring(L, G_KeyNumToName(event->realkey));
+	else if (fastcmp(field,"realnum"))
+		lua_pushinteger(L, event->realkey);
 	else if (fastcmp(field,"repeated"))
 		lua_pushboolean(L, event->repeated);
 	else

src/m_cheat.c

@@ -203,11 +203,11 @@ boolean cht_Responder(event_t *ev)
 	if (ev->type != ev_keydown)
 		return false;
 
-	if (ev->key > 0xFF)
+	if (ev->realkey > 0xFF)
 	{
 		// map some fake (joy) inputs into keys
 		// map joy inputs into keys
-		switch (ev->key)
+		switch (ev->realkey)
 		{
 			case KEY_JOY1:
 			case KEY_JOY1 + 2:
@@ -231,7 +231,7 @@ boolean cht_Responder(event_t *ev)
 		}
 	}
 	else
-		ch = (UINT8)ev->key;
+		ch = (UINT8)ev->realkey;
 
 	ret += cht_CheckCheat(&cheat_ultimate, (char)ch);
 	ret += cht_CheckCheat(&cheat_ultimate_joy, (char)ch);

src/m_menu.c

@@ -3260,9 +3260,12 @@ boolean M_Responder(event_t *ev)
 				case KEY_HAT1 + 3:
 					ch = KEY_RIGHTARROW;
 					break;
+				default: // Not a virtual key? Remap it.
+					ch = ev->realkey;
+					break;
 			}
 		}
-		else if (ev->type == ev_joystick  && ev->key == 0 && joywait < I_GetTime())
+		else if (ev->type == ev_joystick  && ev->realkey == 0 && joywait < I_GetTime())
 		{
 			const INT32 jdeadzone = (JOYAXISRANGE * cv_digitaldeadzone.value) / FRACUNIT;
 			if (ev->y != INT32_MAX)
@@ -3339,7 +3342,7 @@ boolean M_Responder(event_t *ev)
 			keydown = 0;
 	}
 	else if (ev->type == ev_keydown) // Preserve event for other responders
-		ch = ev->key;
+		ch = ev->realkey; // use layouted key here
 
 	if (ch == -1)
 		return false;
@@ -3464,7 +3467,7 @@ boolean M_Responder(event_t *ev)
 	{
 		if ((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_STRING)
 		{
-			if (M_ChangeStringCvar(ch))
+			if (M_ChangeStringCvar(ev->realkey))
 				return true;
 			else
 				routine = NULL;

src/sdl/i_system.c

@@ -592,6 +592,9 @@ void I_GetConsoleEvents(void)
 		// print the current line (this is differential)
 		d = write(STDOUT_FILENO, &key, 1);
 	}
+
+	ev.realkey = ev.key;
+
 	if (ev.key) D_PostEvent(&ev);
 	//tty_FlushIn();
 	(void)d;
@@ -1012,7 +1015,7 @@ void I_ShutdownJoystick(void)
 
 void I_GetJoystickEvents(void)
 {
-	static event_t event = {0,0,0,0,false};
+	static event_t event = {0,0,0,0,0,false};
 	INT32 i = 0;
 	UINT64 joyhats = 0;
 #if 0
@@ -1282,7 +1285,7 @@ void I_ShutdownJoystick2(void)
 
 void I_GetJoystick2Events(void)
 {
-	static event_t event = {0,0,0,0,false};
+	static event_t event = {0,0,0,0,0,false};
 	INT32 i = 0;
 	UINT64 joyhats = 0;
 #if 0

src/sdl/i_video.c

@@ -363,6 +363,92 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
 	return 0;
 }
 
+static INT32 Impl_SDL_Keycode_To_Keycode(SDL_Keycode code)
+{
+	if (code >= SDLK_a && code <= SDLK_z)
+	{
+		// get lowercase ASCII
+		return code - SDLK_a + 'a';
+	}
+	if (code >= SDLK_0 && code <= SDLK_9)
+	{
+		return code - SDLK_0 + '0';
+	}
+	if (code >= SDLK_F1 && code <= SDLK_F10)
+	{
+		return KEY_F1 + (code - SDLK_F1);
+	}
+	switch (code)
+	{
+		// F11 and F12 are separated from the rest of the function keys
+		case SDLK_F11: return KEY_F11;
+		case SDLK_F12: return KEY_F12;
+
+		case SDLK_KP_0: return KEY_KEYPAD0;
+		case SDLK_KP_1: return KEY_KEYPAD1;
+		case SDLK_KP_2: return KEY_KEYPAD2;
+		case SDLK_KP_3: return KEY_KEYPAD3;
+		case SDLK_KP_4: return KEY_KEYPAD4;
+		case SDLK_KP_5: return KEY_KEYPAD5;
+		case SDLK_KP_6: return KEY_KEYPAD6;
+		case SDLK_KP_7: return KEY_KEYPAD7;
+		case SDLK_KP_8: return KEY_KEYPAD8;
+		case SDLK_KP_9: return KEY_KEYPAD9;
+
+		case SDLK_RETURN:         return KEY_ENTER;
+		case SDLK_ESCAPE:         return KEY_ESCAPE;
+		case SDLK_BACKSPACE:      return KEY_BACKSPACE;
+		case SDLK_TAB:            return KEY_TAB;
+		case SDLK_SPACE:          return KEY_SPACE;
+		case SDLK_MINUS:          return KEY_MINUS;
+		case SDLK_EQUALS:         return KEY_EQUALS;
+		case SDLK_LEFTBRACKET:    return '[';
+		case SDLK_RIGHTBRACKET:   return ']';
+		case SDLK_BACKSLASH:      return '\\';
+		case SDLK_HASH:           return '#';
+		case SDLK_SEMICOLON:      return ';';
+		case SDLK_QUOTE:          return '\'';
+		case SDLK_BACKQUOTE:      return '`';
+		case SDLK_COMMA:          return ',';
+		case SDLK_PERIOD:         return '.';
+		case SDLK_SLASH:          return '/';
+		case SDLK_CAPSLOCK:       return KEY_CAPSLOCK;
+		case SDLK_PRINTSCREEN:    return 0; // undefined?
+		case SDLK_SCROLLLOCK:     return KEY_SCROLLLOCK;
+		case SDLK_PAUSE:          return KEY_PAUSE;
+		case SDLK_INSERT:         return KEY_INS;
+		case SDLK_HOME:           return KEY_HOME;
+		case SDLK_PAGEUP:         return KEY_PGUP;
+		case SDLK_DELETE:         return KEY_DEL;
+		case SDLK_END:            return KEY_END;
+		case SDLK_PAGEDOWN:       return KEY_PGDN;
+		case SDLK_RIGHT:          return KEY_RIGHTARROW;
+		case SDLK_LEFT:           return KEY_LEFTARROW;
+		case SDLK_DOWN:           return KEY_DOWNARROW;
+		case SDLK_UP:             return KEY_UPARROW;
+		case SDLK_NUMLOCKCLEAR:   return KEY_NUMLOCK;
+		case SDLK_KP_DIVIDE:      return KEY_KPADSLASH;
+		case SDLK_KP_MULTIPLY:    return '*'; // undefined?
+		case SDLK_KP_MINUS:       return KEY_MINUSPAD;
+		case SDLK_KP_PLUS:        return KEY_PLUSPAD;
+		case SDLK_KP_ENTER:       return KEY_ENTER;
+		case SDLK_KP_PERIOD:      return KEY_KPADDEL;
+		//case SDLK_NONUSBACKSLASH: return '\\';
+
+		case SDLK_LSHIFT: return KEY_LSHIFT;
+		case SDLK_RSHIFT: return KEY_RSHIFT;
+		case SDLK_LCTRL:  return KEY_LCTRL;
+		case SDLK_RCTRL:  return KEY_RCTRL;
+		case SDLK_LALT:   return KEY_LALT;
+		case SDLK_RALT:   return KEY_RALT;
+		case SDLK_LGUI:   return KEY_LEFTWIN;
+		case SDLK_RGUI:   return KEY_RIGHTWIN;
+		default:          break;
+	}
+
+	return 0;
+}
+
 static boolean IgnoreMouse(void)
 {
 	if (cv_alwaysgrabmouse.value)
@@ -668,6 +754,7 @@ static void Impl_HandleKeyboardEvent(SDL_KeyboardEvent evt, Uint32 type)
 		return;
 	}
 	event.key = Impl_SDL_Scancode_To_Keycode(evt.keysym.scancode);
+	event.realkey = Impl_SDL_Keycode_To_Keycode(evt.keysym.sym);
 	event.repeated = (evt.repeat != 0);
 	if (event.key) D_PostEvent(&event);
 }
@@ -756,6 +843,9 @@ static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
 			event.key = KEY_MOUSE1+3;
 		else if (evt.button == SDL_BUTTON_X2)
 			event.key = KEY_MOUSE1+4;
+
+		event.realkey = event.key;
+
 		if (event.type == ev_keyup || event.type == ev_keydown)
 		{
 			D_PostEvent(&event);
@@ -784,6 +874,9 @@ static void Impl_HandleMouseWheelEvent(SDL_MouseWheelEvent evt)
 		event.key = 0;
 		event.type = ev_keyup;
 	}
+
+	event.realkey = event.key;
+
 	if (event.type == ev_keyup || event.type == ev_keydown)
 	{
 		D_PostEvent(&event);
@@ -826,6 +919,9 @@ static void Impl_HandleJoystickAxisEvent(SDL_JoyAxisEvent evt)
 		event.key = evt.axis / 2;
 		event.y = SDLJoyAxis(evt.value, event.type);
 	}
+
+	event.realkey = event.key;
+
 	D_PostEvent(&event);
 }
 
@@ -889,6 +985,8 @@ static void Impl_HandleJoystickButtonEvent(SDL_JoyButtonEvent evt, Uint32 type)
 	}
 	else return;
 
+	event.realkey = event.key;
+
 	SDLJoyRemap(&event);
 	if (event.type != ev_console) D_PostEvent(&event);
 }
@@ -1089,7 +1187,7 @@ void I_GetEvent(void)
 		SDL_GetWindowSize(window, &wwidth, &wheight);
 		//SDL_memset(&event, 0, sizeof(event_t));
 		event.type = ev_mouse;
-		event.key = 0;
+		event.realkey = event.key = 0;
 		event.x = (INT32)lround(mousemovex * ((float)wwidth / (float)realwidth));
 		event.y = (INT32)lround(mousemovey * ((float)wheight / (float)realheight));
 		D_PostEvent(&event);