mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-14 01:19:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use SK_* keysyms (pretty much SDL 1.2).

Browse Source
This commit is contained in:
Themaister 2011-09-13 14:40:33 +02:00
parent 924848fdad
commit 23516572b7
7 changed files with 481 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
config.def.h
View File

@ -30,17 +30,12 @@
#include "config.h"
#endif
#ifdef HAVE_SDL
#include "SDL.h"
#else
#error "HAVE_SDL is not defined!"
#endif
#include "input/keysym.h"
#ifdef HAVE_SRC
#include <samplerate.h>
#endif
///////////////// Drivers
#define VIDEO_GL 0
#define VIDEO_XVIDEO 11
@ -231,57 +226,57 @@ static const float axis_threshold = 0.5;
// Player 1
static const struct snes_keybind snes_keybinds_1[] = {
// SNES button | keyboard key | js btn | js axis |
{ SNES_DEVICE_ID_JOYPAD_A, SDLK_x, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_B, SDLK_z, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_X, SDLK_s, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_Y, SDLK_a, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_L, SDLK_q, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_R, SDLK_w, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_LEFT, SDLK_LEFT, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_RIGHT, SDLK_RIGHT, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_UP, SDLK_UP, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_DOWN, SDLK_DOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_START, SDLK_RETURN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_SELECT, SDLK_RSHIFT, NO_BTN, AXIS_NONE },
{ SSNES_FAST_FORWARD_KEY, SDLK_SPACE, NO_BTN, AXIS_NONE },
{ SSNES_FAST_FORWARD_HOLD_KEY, SDLK_l, NO_BTN, AXIS_NONE },
{ SSNES_SAVE_STATE_KEY, SDLK_F2, NO_BTN, AXIS_NONE },
{ SSNES_LOAD_STATE_KEY, SDLK_F4, NO_BTN, AXIS_NONE },
{ SSNES_FULLSCREEN_TOGGLE_KEY, SDLK_f, NO_BTN, AXIS_NONE },
{ SSNES_QUIT_KEY, SDLK_ESCAPE, NO_BTN, AXIS_NONE },
{ SSNES_STATE_SLOT_MINUS, SDLK_F6, NO_BTN, AXIS_NONE },
{ SSNES_STATE_SLOT_PLUS, SDLK_F7, NO_BTN, AXIS_NONE },
{ SSNES_AUDIO_INPUT_RATE_PLUS, SDLK_KP_PLUS, NO_BTN, AXIS_NONE },
{ SSNES_AUDIO_INPUT_RATE_MINUS, SDLK_KP_MINUS, NO_BTN, AXIS_NONE },
{ SSNES_REWIND, SDLK_r, NO_BTN, AXIS_NONE },
{ SSNES_MOVIE_RECORD_TOGGLE, SDLK_o, NO_BTN, AXIS_NONE },
{ SSNES_PAUSE_TOGGLE, SDLK_p, NO_BTN, AXIS_NONE },
{ SSNES_RESET, SDLK_h, NO_BTN, AXIS_NONE },
{ SSNES_SHADER_NEXT, SDLK_m, NO_BTN, AXIS_NONE },
{ SSNES_SHADER_PREV, SDLK_n, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_INDEX_PLUS, SDLK_y, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_INDEX_MINUS, SDLK_t, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_TOGGLE, SDLK_u, NO_BTN, AXIS_NONE },
{ SSNES_SCREENSHOT, SDLK_PRINT, NO_BTN, AXIS_NONE },
{ SSNES_DSP_CONFIG, SDLK_c, NO_BTN, AXIS_NONE },
// SNES button | keyboard key | js btn | js axis |
{ SNES_DEVICE_ID_JOYPAD_A, SK_x, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_B, SK_z, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_X, SK_s, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_Y, SK_a, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_L, SK_q, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_R, SK_w, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_LEFT, SK_LEFT, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_RIGHT, SK_RIGHT, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_UP, SK_UP, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_DOWN, SK_DOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_START, SK_RETURN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_SELECT, SK_RSHIFT, NO_BTN, AXIS_NONE },
{ SSNES_FAST_FORWARD_KEY, SK_SPACE, NO_BTN, AXIS_NONE },
{ SSNES_FAST_FORWARD_HOLD_KEY, SK_l, NO_BTN, AXIS_NONE },
{ SSNES_SAVE_STATE_KEY, SK_F2, NO_BTN, AXIS_NONE },
{ SSNES_LOAD_STATE_KEY, SK_F4, NO_BTN, AXIS_NONE },
{ SSNES_FULLSCREEN_TOGGLE_KEY, SK_f, NO_BTN, AXIS_NONE },
{ SSNES_QUIT_KEY, SK_ESCAPE, NO_BTN, AXIS_NONE },
{ SSNES_STATE_SLOT_MINUS, SK_F6, NO_BTN, AXIS_NONE },
{ SSNES_STATE_SLOT_PLUS, SK_F7, NO_BTN, AXIS_NONE },
{ SSNES_AUDIO_INPUT_RATE_PLUS, SK_KP_PLUS, NO_BTN, AXIS_NONE },
{ SSNES_AUDIO_INPUT_RATE_MINUS, SK_KP_MINUS, NO_BTN, AXIS_NONE },
{ SSNES_REWIND, SK_r, NO_BTN, AXIS_NONE },
{ SSNES_MOVIE_RECORD_TOGGLE, SK_o, NO_BTN, AXIS_NONE },
{ SSNES_PAUSE_TOGGLE, SK_p, NO_BTN, AXIS_NONE },
{ SSNES_RESET, SK_h, NO_BTN, AXIS_NONE },
{ SSNES_SHADER_NEXT, SK_m, NO_BTN, AXIS_NONE },
{ SSNES_SHADER_PREV, SK_n, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_INDEX_PLUS, SK_y, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_INDEX_MINUS, SK_t, NO_BTN, AXIS_NONE },
{ SSNES_CHEAT_TOGGLE, SK_u, NO_BTN, AXIS_NONE },
{ SSNES_SCREENSHOT, SK_PRINT, NO_BTN, AXIS_NONE },
{ SSNES_DSP_CONFIG, SK_c, NO_BTN, AXIS_NONE },
{ -1 }
};
// Player 2-5
static const struct snes_keybind snes_keybinds_rest[] = {
{ SNES_DEVICE_ID_JOYPAD_A, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_B, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_X, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_Y, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_L, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_R, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_LEFT, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_RIGHT, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_UP, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_DOWN, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_START, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_SELECT, SDLK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_A, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_B, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_X, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_Y, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_L, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_R, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_LEFT, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_RIGHT, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_UP, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_DOWN, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_START, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ SNES_DEVICE_ID_JOYPAD_SELECT, SK_UNKNOWN, NO_BTN, AXIS_NONE },
{ -1 }
};

3
driver.h
View File

@ -24,6 +24,7 @@
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include "input/keysym.h"
enum
{
@ -56,7 +57,7 @@ enum
struct snes_keybind
{
int id;
uint32_t key;
enum ssnes_key key;
uint16_t joykey;
uint32_t joyaxis;
};

3
gfx/ext/ssnes_video.h
View File

@ -155,8 +155,9 @@ struct ssnes_keybind
// last frame and current frame in the Y-axis.
int analog_y;
// Keyboard key. The key values use the SDL keysyms,
// Keyboard key. The key values use the SDL 1.2 keysyms,
// which probably need to be transformed to the native format.
// The actual keysyms SSNES uses are found in input/keysym.h.
unsigned short key;
// Joypad key. Joypad POV (hats) are embedded into this key as well.

173
input/keysym.h Normal file
View File

@ -0,0 +1,173 @@
/* SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
* Copyright (C) 2010-2011 - Hans-Kristian Arntzen
*
* Some code herein may be based on code found in BSNES.
*
* SSNES 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 Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* SSNES 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 SSNES.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __SSNES_KEYSYM_H
#define __SSNES_KEYSYM_H
// Global keysym table for SSNES.
// As you may have noticed, it's the same as SDL 1.2 since I'm lazy.
enum ssnes_key
{
SK_UNKNOWN = 0,
SK_FIRST = 0,
SK_BACKSPACE = 8,
SK_TAB = 9,
SK_CLEAR = 12,
SK_RETURN = 13,
SK_PAUSE = 19,
SK_ESCAPE = 27,
SK_SPACE = 32,
SK_EXCLAIM = 33,
SK_QUOTEDBL = 34,
SK_HASH = 35,
SK_DOLLAR = 36,
SK_AMPERSAND = 38,
SK_QUOTE = 39,
SK_LEFTPAREN = 40,
SK_RIGHTPAREN = 41,
SK_ASTERISK = 42,
SK_PLUS = 43,
SK_COMMA = 44,
SK_MINUS = 45,
SK_PERIOD = 46,
SK_SLASH = 47,
SK_0 = 48,
SK_1 = 49,
SK_2 = 50,
SK_3 = 51,
SK_4 = 52,
SK_5 = 53,
SK_6 = 54,
SK_7 = 55,
SK_8 = 56,
SK_9 = 57,
SK_COLON = 58,
SK_SEMICOLON = 59,
SK_LESS = 60,
SK_EQUALS = 61,
SK_GREATER = 62,
SK_QUESTION = 63,
SK_AT = 64,
SK_LEFTBRACKET = 91,
SK_BACKSLASH = 92,
SK_RIGHTBRACKET = 93,
SK_CARET = 94,
SK_UNDERSCORE = 95,
SK_BACKQUOTE = 96,
SK_a = 97,
SK_b = 98,
SK_c = 99,
SK_d = 100,
SK_e = 101,
SK_f = 102,
SK_g = 103,
SK_h = 104,
SK_i = 105,
SK_j = 106,
SK_k = 107,
SK_l = 108,
SK_m = 109,
SK_n = 110,
SK_o = 111,
SK_p = 112,
SK_q = 113,
SK_r = 114,
SK_s = 115,
SK_t = 116,
SK_u = 117,
SK_v = 118,
SK_w = 119,
SK_x = 120,
SK_y = 121,
SK_z = 122,
SK_DELETE = 127,
SK_KP0 = 256,
SK_KP1 = 257,
SK_KP2 = 258,
SK_KP3 = 259,
SK_KP4 = 260,
SK_KP5 = 261,
SK_KP6 = 262,
SK_KP7 = 263,
SK_KP8 = 264,
SK_KP9 = 265,
SK_KP_PERIOD = 266,
SK_KP_DIVIDE = 267,
SK_KP_MULTIPLY = 268,
SK_KP_MINUS = 269,
SK_KP_PLUS = 270,
SK_KP_ENTER = 271,
SK_KP_EQUALS = 272,
SK_UP = 273,
SK_DOWN = 274,
SK_RIGHT = 275,
SK_LEFT = 276,
SK_INSERT = 277,
SK_HOME = 278,
SK_END = 279,
SK_PAGEUP = 280,
SK_PAGEDOWN = 281,
SK_F1 = 282,
SK_F2 = 283,
SK_F3 = 284,
SK_F4 = 285,
SK_F5 = 286,
SK_F6 = 287,
SK_F7 = 288,
SK_F8 = 289,
SK_F9 = 290,
SK_F10 = 291,
SK_F11 = 292,
SK_F12 = 293,
SK_F13 = 294,
SK_F14 = 295,
SK_F15 = 296,
SK_NUMLOCK = 300,
SK_CAPSLOCK = 301,
SK_SCROLLOCK = 302,
SK_RSHIFT = 303,
SK_LSHIFT = 304,
SK_RCTRL = 305,
SK_LCTRL = 306,
SK_RALT = 307,
SK_LALT = 308,
SK_RMETA = 309,
SK_LMETA = 310,
SK_LSUPER = 311,
SK_RSUPER = 312,
SK_MODE = 313,
SK_COMPOSE = 314,
SK_HELP = 315,
SK_PRINT = 316,
SK_SYSREQ = 317,
SK_BREAK = 318,
SK_MENU = 319,
SK_POWER = 320,
SK_EURO = 321,
SK_UNDO = 322,
SK_LAST
};
#endif

99
input/sdl.c
View File

@ -24,10 +24,107 @@
#include <stdlib.h>
#include <libsnes.hpp>
#include "ssnes_sdl_input.h"
#include "keysym.h"
struct key_bind
{
unsigned sdl;
enum ssnes_key sk;
};
static unsigned keysym_lut[SK_LAST];
static const struct key_bind lut_binds[] = {
{ SDLK_LEFT, SK_LEFT },
{ SDLK_RIGHT, SK_RIGHT },
{ SDLK_UP, SK_UP },
{ SDLK_DOWN, SK_DOWN },
{ SDLK_RETURN, SK_RETURN },
{ SDLK_TAB, SK_TAB },
{ SDLK_INSERT, SK_INSERT },
{ SDLK_DELETE, SK_DELETE },
{ SDLK_RSHIFT, SK_RSHIFT },
{ SDLK_LSHIFT, SK_LSHIFT },
{ SDLK_LCTRL, SK_LCTRL },
{ SDLK_LALT, SK_LALT },
{ SDLK_SPACE, SK_SPACE },
{ SDLK_ESCAPE, SK_ESCAPE },
{ SDLK_BACKSPACE, SK_BACKSPACE },
{ SDLK_KP_ENTER, SK_KP_ENTER },
{ SDLK_KP_PLUS, SK_KP_PLUS },
{ SDLK_KP_MINUS, SK_KP_MINUS },
{ SDLK_KP_MULTIPLY, SK_KP_MULTIPLY },
{ SDLK_KP_DIVIDE, SK_KP_DIVIDE },
{ SDLK_BACKQUOTE, SK_BACKQUOTE },
{ SDLK_KP0, SK_KP0 },
{ SDLK_KP1, SK_KP1 },
{ SDLK_KP2, SK_KP2 },
{ SDLK_KP3, SK_KP3 },
{ SDLK_KP4, SK_KP4 },
{ SDLK_KP5, SK_KP5 },
{ SDLK_KP6, SK_KP6 },
{ SDLK_KP7, SK_KP7 },
{ SDLK_KP8, SK_KP8 },
{ SDLK_KP9, SK_KP9 },
{ SDLK_0, SK_0 },
{ SDLK_1, SK_1 },
{ SDLK_2, SK_2 },
{ SDLK_3, SK_3 },
{ SDLK_4, SK_4 },
{ SDLK_5, SK_5 },
{ SDLK_6, SK_6 },
{ SDLK_7, SK_7 },
{ SDLK_8, SK_8 },
{ SDLK_9, SK_9 },
{ SDLK_F1, SK_F1 },
{ SDLK_F2, SK_F2 },
{ SDLK_F3, SK_F3 },
{ SDLK_F4, SK_F4 },
{ SDLK_F5, SK_F5 },
{ SDLK_F6, SK_F6 },
{ SDLK_F7, SK_F7 },
{ SDLK_F8, SK_F8 },
{ SDLK_F9, SK_F9 },
{ SDLK_F10, SK_F10 },
{ SDLK_F11, SK_F11 },
{ SDLK_F12, SK_F12 },
{ SDLK_a, SK_a },
{ SDLK_b, SK_b },
{ SDLK_c, SK_c },
{ SDLK_d, SK_d },
{ SDLK_e, SK_e },
{ SDLK_f, SK_f },
{ SDLK_g, SK_g },
{ SDLK_h, SK_h },
{ SDLK_i, SK_i },
{ SDLK_j, SK_j },
{ SDLK_k, SK_k },
{ SDLK_l, SK_l },
{ SDLK_m, SK_m },
{ SDLK_n, SK_n },
{ SDLK_o, SK_o },
{ SDLK_p, SK_p },
{ SDLK_q, SK_q },
{ SDLK_r, SK_r },
{ SDLK_s, SK_s },
{ SDLK_t, SK_t },
{ SDLK_u, SK_u },
{ SDLK_v, SK_v },
{ SDLK_w, SK_w },
{ SDLK_x, SK_x },
{ SDLK_y, SK_y },
{ SDLK_z, SK_z },
};
static void init_lut(void)
{
memset(keysym_lut, 0, sizeof(keysym_lut));
for (unsigned i = 0; i < sizeof(lut_binds) / sizeof(lut_binds[0]); i++)
keysym_lut[lut_binds[i].sk] = lut_binds[i].sdl;
}
static void* sdl_input_init(void)
{
init_lut();
sdl_input_t *sdl = calloc(1, sizeof(*sdl));
if (!sdl)
return NULL;
@ -78,7 +175,7 @@ static void* sdl_input_init(void)
static bool sdl_key_pressed(int key)
{
return sdlwrap_key_pressed(key);
return sdlwrap_key_pressed(keysym_lut[key]);
}
#ifndef HAVE_DINPUT

175
input/x11_input.c
View File

@ -23,6 +23,7 @@
#include <stdint.h>
#include <stdlib.h>
#include "ssnes_sdl_input.h"
#include "keysym.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
@ -37,104 +38,98 @@ typedef struct x11_input
struct key_bind
{
int x;
int sdl;
unsigned x;
enum ssnes_key sk;
};
#define LUT_SIZE 1024
#define LUT_MASK (LUT_SIZE - 1)
static int keysym_lut[LUT_SIZE];
static unsigned keysym_lut[SK_LAST];
static const struct key_bind lut_binds[] = {
{ XK_Left, SDLK_LEFT },
{ XK_Right, SDLK_RIGHT },
{ XK_Up, SDLK_UP },
{ XK_Down, SDLK_DOWN },
{ XK_Return, SDLK_RETURN },
{ XK_Tab, SDLK_TAB },
{ XK_Insert, SDLK_INSERT },
{ XK_Delete, SDLK_DELETE },
{ XK_Shift_R, SDLK_RSHIFT },
{ XK_Shift_L, SDLK_LSHIFT },
{ XK_Control_L, SDLK_LCTRL },
{ XK_Alt_L, SDLK_LALT },
{ XK_space, SDLK_SPACE },
{ XK_Escape, SDLK_ESCAPE },
{ XK_KP_Add, SDLK_KP_PLUS },
{ XK_KP_Subtract, SDLK_KP_MINUS },
{ XK_BackSpace, SDLK_BACKSPACE },
{ XK_KP_Enter, SDLK_KP_ENTER },
{ XK_KP_Add, SDLK_KP_PLUS },
{ XK_KP_Subtract, SDLK_KP_MINUS },
{ XK_KP_Multiply, SDLK_KP_MULTIPLY },
{ XK_KP_Divide, SDLK_KP_DIVIDE },
{ XK_grave, SDLK_BACKQUOTE },
{ XK_KP_0, SDLK_KP0 },
{ XK_KP_1, SDLK_KP1 },
{ XK_KP_2, SDLK_KP2 },
{ XK_KP_3, SDLK_KP3 },
{ XK_KP_4, SDLK_KP4 },
{ XK_KP_5, SDLK_KP5 },
{ XK_KP_6, SDLK_KP6 },
{ XK_KP_7, SDLK_KP7 },
{ XK_KP_8, SDLK_KP8 },
{ XK_KP_9, SDLK_KP9 },
{ XK_0, SDLK_0 },
{ XK_1, SDLK_1 },
{ XK_2, SDLK_2 },
{ XK_3, SDLK_3 },
{ XK_4, SDLK_4 },
{ XK_5, SDLK_5 },
{ XK_6, SDLK_6 },
{ XK_7, SDLK_7 },
{ XK_8, SDLK_8 },
{ XK_9, SDLK_9 },
{ XK_F1, SDLK_F1 },
{ XK_F2, SDLK_F2 },
{ XK_F3, SDLK_F3 },
{ XK_F4, SDLK_F4 },
{ XK_F5, SDLK_F5 },
{ XK_F6, SDLK_F6 },
{ XK_F7, SDLK_F7 },
{ XK_F8, SDLK_F8 },
{ XK_F9, SDLK_F9 },
{ XK_F10, SDLK_F10 },
{ XK_F11, SDLK_F11 },
{ XK_F12, SDLK_F12 },
{ XK_a, SDLK_a },
{ XK_b, SDLK_b },
{ XK_c, SDLK_c },
{ XK_d, SDLK_d },
{ XK_e, SDLK_e },
{ XK_f, SDLK_f },
{ XK_g, SDLK_g },
{ XK_h, SDLK_h },
{ XK_i, SDLK_i },
{ XK_j, SDLK_j },
{ XK_k, SDLK_k },
{ XK_l, SDLK_l },
{ XK_m, SDLK_m },
{ XK_n, SDLK_n },
{ XK_o, SDLK_o },
{ XK_p, SDLK_p },
{ XK_q, SDLK_q },
{ XK_r, SDLK_r },
{ XK_s, SDLK_s },
{ XK_t, SDLK_t },
{ XK_u, SDLK_u },
{ XK_v, SDLK_v },
{ XK_w, SDLK_w },
{ XK_x, SDLK_x },
{ XK_y, SDLK_y },
{ XK_z, SDLK_z },
{ XK_Left, SK_LEFT },
{ XK_Right, SK_RIGHT },
{ XK_Up, SK_UP },
{ XK_Down, SK_DOWN },
{ XK_Return, SK_RETURN },
{ XK_Tab, SK_TAB },
{ XK_Insert, SK_INSERT },
{ XK_Delete, SK_DELETE },
{ XK_Shift_R, SK_RSHIFT },
{ XK_Shift_L, SK_LSHIFT },
{ XK_Control_L, SK_LCTRL },
{ XK_Alt_L, SK_LALT },
{ XK_space, SK_SPACE },
{ XK_Escape, SK_ESCAPE },
{ XK_BackSpace, SK_BACKSPACE },
{ XK_KP_Enter, SK_KP_ENTER },
{ XK_KP_Add, SK_KP_PLUS },
{ XK_KP_Subtract, SK_KP_MINUS },
{ XK_KP_Multiply, SK_KP_MULTIPLY },
{ XK_KP_Divide, SK_KP_DIVIDE },
{ XK_grave, SK_BACKQUOTE },
{ XK_KP_0, SK_KP0 },
{ XK_KP_1, SK_KP1 },
{ XK_KP_2, SK_KP2 },
{ XK_KP_3, SK_KP3 },
{ XK_KP_4, SK_KP4 },
{ XK_KP_5, SK_KP5 },
{ XK_KP_6, SK_KP6 },
{ XK_KP_7, SK_KP7 },
{ XK_KP_8, SK_KP8 },
{ XK_KP_9, SK_KP9 },
{ XK_0, SK_0 },
{ XK_1, SK_1 },
{ XK_2, SK_2 },
{ XK_3, SK_3 },
{ XK_4, SK_4 },
{ XK_5, SK_5 },
{ XK_6, SK_6 },
{ XK_7, SK_7 },
{ XK_8, SK_8 },
{ XK_9, SK_9 },
{ XK_F1, SK_F1 },
{ XK_F2, SK_F2 },
{ XK_F3, SK_F3 },
{ XK_F4, SK_F4 },
{ XK_F5, SK_F5 },
{ XK_F6, SK_F6 },
{ XK_F7, SK_F7 },
{ XK_F8, SK_F8 },
{ XK_F9, SK_F9 },
{ XK_F10, SK_F10 },
{ XK_F11, SK_F11 },
{ XK_F12, SK_F12 },
{ XK_a, SK_a },
{ XK_b, SK_b },
{ XK_c, SK_c },
{ XK_d, SK_d },
{ XK_e, SK_e },
{ XK_f, SK_f },
{ XK_g, SK_g },
{ XK_h, SK_h },
{ XK_i, SK_i },
{ XK_j, SK_j },
{ XK_k, SK_k },
{ XK_l, SK_l },
{ XK_m, SK_m },
{ XK_n, SK_n },
{ XK_o, SK_o },
{ XK_p, SK_p },
{ XK_q, SK_q },
{ XK_r, SK_r },
{ XK_s, SK_s },
{ XK_t, SK_t },
{ XK_u, SK_u },
{ XK_v, SK_v },
{ XK_w, SK_w },
{ XK_x, SK_x },
{ XK_y, SK_y },
{ XK_z, SK_z },
};
static void init_lut(void)
{
memset(keysym_lut, 0, sizeof(keysym_lut));
for (unsigned i = 0; i < sizeof(lut_binds) / sizeof(lut_binds[0]); i++)
keysym_lut[lut_binds[i].sdl & LUT_MASK] = lut_binds[i].x;
keysym_lut[lut_binds[i].sk] = lut_binds[i].x;
}
static void* x_input_init(void)
@ -165,7 +160,7 @@ static void* x_input_init(void)
static bool x_key_pressed(x11_input_t *x11, int key)
{
key = keysym_lut[key & LUT_MASK];
key = keysym_lut[key];
int keycode = XKeysymToKeycode(x11->display, key);
bool ret = x11->state[keycode >> 3] & (1 << (keycode & 7));
return ret;

147
settings.c
View File

@ -17,6 +17,7 @@
#include "general.h"
#include "conf/config_file.h"
#include "input/keysym.h"
#include <assert.h>
#include "strl.h"
#include "config.def.h"
@ -640,71 +641,71 @@ struct key_map
// Edit: Not portable to different input systems atm. Might move this map into the driver itself or something.
// However, this should map nicely over to other systems aswell since the definition are mostly the same anyways.
static const struct key_map sdlk_map[] = {
{ "left", SDLK_LEFT },
{ "right", SDLK_RIGHT },
{ "up", SDLK_UP },
{ "down", SDLK_DOWN },
{ "enter", SDLK_RETURN },
{ "kp_enter", SDLK_KP_ENTER },
{ "tab", SDLK_TAB },
{ "insert", SDLK_INSERT },
{ "del", SDLK_DELETE },
{ "end", SDLK_END },
{ "home", SDLK_HOME },
{ "rshift", SDLK_RSHIFT },
{ "shift", SDLK_LSHIFT },
{ "ctrl", SDLK_LCTRL },
{ "alt", SDLK_LALT },
{ "space", SDLK_SPACE },
{ "escape", SDLK_ESCAPE },
{ "add", SDLK_KP_PLUS },
{ "subtract", SDLK_KP_MINUS },
{ "f1", SDLK_F1 },
{ "f2", SDLK_F2 },
{ "f3", SDLK_F3 },
{ "f4", SDLK_F4 },
{ "f5", SDLK_F5 },
{ "f6", SDLK_F6 },
{ "f7", SDLK_F7 },
{ "f8", SDLK_F8 },
{ "f9", SDLK_F9 },
{ "f10", SDLK_F10 },
{ "f11", SDLK_F11 },
{ "f12", SDLK_F12 },
{ "num0", SDLK_0 },
{ "num1", SDLK_1 },
{ "num2", SDLK_2 },
{ "num3", SDLK_3 },
{ "num4", SDLK_4 },
{ "num5", SDLK_5 },
{ "num6", SDLK_6 },
{ "num7", SDLK_7 },
{ "num8", SDLK_8 },
{ "num9", SDLK_9 },
{ "pageup", SDLK_PAGEUP },
{ "pagedown", SDLK_PAGEDOWN },
{ "keypad0", SDLK_KP0 },
{ "keypad1", SDLK_KP1 },
{ "keypad2", SDLK_KP2 },
{ "keypad3", SDLK_KP3 },
{ "keypad4", SDLK_KP4 },
{ "keypad5", SDLK_KP5 },
{ "keypad6", SDLK_KP6 },
{ "keypad7", SDLK_KP7 },
{ "keypad8", SDLK_KP8 },
{ "keypad9", SDLK_KP9 },
{ "period", SDLK_PERIOD },
{ "capslock", SDLK_CAPSLOCK },
{ "numlock", SDLK_NUMLOCK },
{ "backspace", SDLK_BACKSPACE },
{ "multiply", SDLK_KP_MULTIPLY },
{ "divide", SDLK_KP_DIVIDE },
{ "print_screen", SDLK_PRINT },
{ "scroll_lock", SDLK_SCROLLOCK },
{ "tilde", SDLK_BACKQUOTE },
{ "backquote", SDLK_BACKQUOTE },
{ "nul", SDLK_UNKNOWN },
static const struct key_map sk_map[] = {
{ "left", SK_LEFT },
{ "right", SK_RIGHT },
{ "up", SK_UP },
{ "down", SK_DOWN },
{ "enter", SK_RETURN },
{ "kp_enter", SK_KP_ENTER },
{ "tab", SK_TAB },
{ "insert", SK_INSERT },
{ "del", SK_DELETE },
{ "end", SK_END },
{ "home", SK_HOME },
{ "rshift", SK_RSHIFT },
{ "shift", SK_LSHIFT },
{ "ctrl", SK_LCTRL },
{ "alt", SK_LALT },
{ "space", SK_SPACE },
{ "escape", SK_ESCAPE },
{ "add", SK_KP_PLUS },
{ "subtract", SK_KP_MINUS },
{ "f1", SK_F1 },
{ "f2", SK_F2 },
{ "f3", SK_F3 },
{ "f4", SK_F4 },
{ "f5", SK_F5 },
{ "f6", SK_F6 },
{ "f7", SK_F7 },
{ "f8", SK_F8 },
{ "f9", SK_F9 },
{ "f10", SK_F10 },
{ "f11", SK_F11 },
{ "f12", SK_F12 },
{ "num0", SK_0 },
{ "num1", SK_1 },
{ "num2", SK_2 },
{ "num3", SK_3 },
{ "num4", SK_4 },
{ "num5", SK_5 },
{ "num6", SK_6 },
{ "num7", SK_7 },
{ "num8", SK_8 },
{ "num9", SK_9 },
{ "pageup", SK_PAGEUP },
{ "pagedown", SK_PAGEDOWN },
{ "keypad0", SK_KP0 },
{ "keypad1", SK_KP1 },
{ "keypad2", SK_KP2 },
{ "keypad3", SK_KP3 },
{ "keypad4", SK_KP4 },
{ "keypad5", SK_KP5 },
{ "keypad6", SK_KP6 },
{ "keypad7", SK_KP7 },
{ "keypad8", SK_KP8 },
{ "keypad9", SK_KP9 },
{ "period", SK_PERIOD },
{ "capslock", SK_CAPSLOCK },
{ "numlock", SK_NUMLOCK },
{ "backspace", SK_BACKSPACE },
{ "multiply", SK_KP_MULTIPLY },
{ "divide", SK_KP_DIVIDE },
{ "print_screen", SK_PRINT },
{ "scroll_lock", SK_SCROLLOCK },
{ "tilde", SK_BACKQUOTE },
{ "backquote", SK_BACKQUOTE },
{ "nul", SK_UNKNOWN },
};
static struct snes_keybind *find_snes_bind(unsigned port, int id)
@ -719,23 +720,23 @@ static struct snes_keybind *find_snes_bind(unsigned port, int id)
return NULL;
}
static int find_sdlk_bind(const char *str)
static int find_sk_bind(const char *str)
{
for (int i = 0; i < sizeof(sdlk_map)/sizeof(struct key_map); i++)
for (int i = 0; i < sizeof(sk_map)/sizeof(struct key_map); i++)
{
if (strcasecmp(sdlk_map[i].str, str) == 0)
return sdlk_map[i].key;
if (strcasecmp(sk_map[i].str, str) == 0)
return sk_map[i].key;
}
return -1;
}
static int find_sdlk_key(const char *str)
static int find_sk_key(const char *str)
{
// If the bind is a normal key-press ...
if (strlen(str) == 1 && isalpha(*str))
return (int)SDLK_a + (tolower(*str) - (int)'a');
return (int)SK_a + (tolower(*str) - (int)'a');
else // Check if we have a special mapping for it.
return find_sdlk_bind(str);
return find_sk_bind(str);
}
// Yes, this function needs a good refactor :)
@ -756,7 +757,7 @@ static void read_keybinds(config_file_t *conf)
// Check keybind
if (bind_maps[j][i].key && config_get_string(conf, bind_maps[j][i].key, &tmp_key))
{
int key = find_sdlk_key(tmp_key);
int key = find_sk_key(tmp_key);
if (key >= 0)
bind->key = key;