Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 08:22:15 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add basic keyboard input to UWP (nw)

Browse Source
This commit is contained in:
Brad Hughes 2016-11-11 11:43:49 -05:00
parent c0407f073b
commit 2e49823a06
7 changed files with 334 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/src/osd/modules.lua
View File

@ -101,6 +101,7 @@ function osdmodulesbuild()
MAME_DIR .. "src/osd/modules/input/input_xinput.cpp",
MAME_DIR .. "src/osd/modules/input/input_xinput.h",
MAME_DIR .. "src/osd/modules/input/input_winhybrid.cpp",
MAME_DIR .. "src/osd/modules/input/input_uwp.cpp",
MAME_DIR .. "src/osd/modules/output/output_module.h",
MAME_DIR .. "src/osd/modules/output/none.cpp",
MAME_DIR .. "src/osd/modules/output/console.cpp",

284
src/osd/modules/input/input_common.cpp
View File

@ -29,136 +29,139 @@
#if defined(OSD_WINDOWS)
#include <windows.h>
#define KEY_TRANS_ENTRY0(mame, sdlsc, sdlkey, disc, virtual, ascii, UI) { ITEM_ID_##mame, KEY_ ## disc, virtual, ascii, "ITEM_ID_"#mame, (char *) UI }
#define KEY_TRANS_ENTRY1(mame, sdlsc, sdlkey, disc, virtual, ascii) { ITEM_ID_##mame, KEY_ ## disc, virtual, ascii, "ITEM_ID_"#mame, (char*) #mame }
#define KEY_TRANS_ENTRY0(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii, UI) { ITEM_ID_##mame, KEY_ ## disc, virtual, ascii, "ITEM_ID_"#mame, (char *) UI }
#define KEY_TRANS_ENTRY1(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii) { ITEM_ID_##mame, KEY_ ## disc, virtual, ascii, "ITEM_ID_"#mame, (char*) #mame }
#elif defined(OSD_SDL)
// SDL include
#include <SDL2/SDL.h>
#define KEY_TRANS_ENTRY0(mame, sdlsc, sdlkey, disc, virtual, ascii, UI) { ITEM_ID_##mame, SDL_SCANCODE_ ## sdlsc, SDLK_ ## sdlkey, ascii, "ITEM_ID_"#mame, (char *) UI }
#define KEY_TRANS_ENTRY1(mame, sdlsc, sdlkey, disc, virtual, ascii) { ITEM_ID_##mame, SDL_SCANCODE_ ## sdlsc, SDLK_ ## sdlkey, ascii, "ITEM_ID_"#mame, (char*) #mame }
#define KEY_TRANS_ENTRY0(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii, UI) { ITEM_ID_##mame, SDL_SCANCODE_ ## sdlsc, SDLK_ ## sdlkey, ascii, "ITEM_ID_"#mame, (char *) UI }
#define KEY_TRANS_ENTRY1(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii) { ITEM_ID_##mame, SDL_SCANCODE_ ## sdlsc, SDLK_ ## sdlkey, ascii, "ITEM_ID_"#mame, (char*) #mame }
#elif defined(OSD_UWP)
#define KEY_TRANS_ENTRY0(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii, UI) { ITEM_ID_##mame, Windows::System::VirtualKey:: ## uwp, ascii, "ITEM_ID_"#mame, (char *) UI }
#define KEY_TRANS_ENTRY1(mame, sdlsc, sdlkey, disc, virtual, uwp, ascii) { ITEM_ID_##mame, Windows::System::VirtualKey:: ## uwp, ascii, "ITEM_ID_"#mame, (char*) #mame }
#else
// osd mini
#endif
#if defined(OSD_WINDOWS) || defined(OSD_SDL)
#if defined(OSD_WINDOWS) || defined(OSD_SDL) || defined(OSD_UWP)
key_trans_entry keyboard_trans_table::s_default_table[] =
{
// MAME key sdl scancode sdl key di scancode virtual key ascii ui
KEY_TRANS_ENTRY0(ESC, ESCAPE, ESCAPE, ESCAPE, VK_ESCAPE, 27, "ESCAPE"),
KEY_TRANS_ENTRY1(1, 1, 1, 1, '1', '1'),
KEY_TRANS_ENTRY1(2, 2, 2, 2, '2', '2'),
KEY_TRANS_ENTRY1(3, 3, 3, 3, '3', '3'),
KEY_TRANS_ENTRY1(4, 4, 4, 4, '4', '4'),
KEY_TRANS_ENTRY1(5, 5, 5, 5, '5', '5'),
KEY_TRANS_ENTRY1(6, 6, 6, 6, '6', '6'),
KEY_TRANS_ENTRY1(7, 7, 7, 7, '7', '7'),
KEY_TRANS_ENTRY1(8, 8, 8, 8, '8', '8'),
KEY_TRANS_ENTRY1(9, 9, 9, 9, '9', '9'),
KEY_TRANS_ENTRY1(0, 0, 0, 0, '0', '0'),
KEY_TRANS_ENTRY1(MINUS, MINUS, MINUS, MINUS, VK_OEM_MINUS, '-'),
KEY_TRANS_ENTRY1(EQUALS, EQUALS, EQUALS, EQUALS, VK_OEM_PLUS, '='),
KEY_TRANS_ENTRY1(BACKSPACE, BACKSPACE, BACKSPACE, BACK, VK_BACK, 8),
KEY_TRANS_ENTRY1(TAB, TAB, TAB, TAB, VK_TAB, 9),
KEY_TRANS_ENTRY1(Q, Q, q, Q, 'Q', 'Q'),
KEY_TRANS_ENTRY1(W, W, w, W, 'W', 'W'),
KEY_TRANS_ENTRY1(E, E, e, E, 'E', 'E'),
KEY_TRANS_ENTRY1(R, R, r, R, 'R', 'R'),
KEY_TRANS_ENTRY1(T, T, t, T, 'T', 'T'),
KEY_TRANS_ENTRY1(Y, Y, y, Y, 'Y', 'Y'),
KEY_TRANS_ENTRY1(U, U, u, U, 'U', 'U'),
KEY_TRANS_ENTRY1(I, I, i, I, 'I', 'I'),
KEY_TRANS_ENTRY1(O, O, o, O, 'O', 'O'),
KEY_TRANS_ENTRY1(P, P, p, P, 'P', 'P'),
KEY_TRANS_ENTRY1(OPENBRACE, LEFTBRACKET, LEFTBRACKET, LBRACKET, VK_OEM_4, '['),
KEY_TRANS_ENTRY1(CLOSEBRACE, RIGHTBRACKET, RIGHTBRACKET, RBRACKET, VK_OEM_6, ']'),
KEY_TRANS_ENTRY0(ENTER, RETURN, RETURN, RETURN, VK_RETURN, 13, "RETURN"),
KEY_TRANS_ENTRY1(LCONTROL, LCTRL, LCTRL, LCONTROL, VK_LCONTROL, 0),
KEY_TRANS_ENTRY1(A, A, a, A, 'A', 'A'),
KEY_TRANS_ENTRY1(S, S, s, S, 'S', 'S'),
KEY_TRANS_ENTRY1(D, D, d, D, 'D', 'D'),
KEY_TRANS_ENTRY1(F, F, f, F, 'F', 'F'),
KEY_TRANS_ENTRY1(G, G, g, G, 'G', 'G'),
KEY_TRANS_ENTRY1(H, H, h, H, 'H', 'H'),
KEY_TRANS_ENTRY1(J, J, j, J, 'J', 'J'),
KEY_TRANS_ENTRY1(K, K, k, K, 'K', 'K'),
KEY_TRANS_ENTRY1(L, L, l, L, 'L', 'L'),
KEY_TRANS_ENTRY1(COLON, SEMICOLON, SEMICOLON, SEMICOLON, VK_OEM_1, ';'),
KEY_TRANS_ENTRY1(QUOTE, APOSTROPHE, QUOTE, APOSTROPHE, VK_OEM_7, '\''),
KEY_TRANS_ENTRY1(TILDE, GRAVE, BACKQUOTE, GRAVE, VK_OEM_3, '`'),
KEY_TRANS_ENTRY1(LSHIFT, LSHIFT, LSHIFT, LSHIFT, VK_LSHIFT, 0),
KEY_TRANS_ENTRY1(BACKSLASH, BACKSLASH, BACKSLASH, BACKSLASH, VK_OEM_5, '\\'),
// KEY_TRANS_ENTRY1(BACKSLASH2, NONUSHASH, UNKNOWN, OEM_102, VK_OEM_102, '<'),
// MAME key sdl scancode sdl key di scancode virtual key uwp vkey ascii ui
KEY_TRANS_ENTRY0(ESC, ESCAPE, ESCAPE, ESCAPE, VK_ESCAPE, Escape, 27, "ESCAPE"),
KEY_TRANS_ENTRY1(1, 1, 1, 1, '1', Number1, '1'),
KEY_TRANS_ENTRY1(2, 2, 2, 2, '2', Number2, '2'),
KEY_TRANS_ENTRY1(3, 3, 3, 3, '3', Number3, '3'),
KEY_TRANS_ENTRY1(4, 4, 4, 4, '4', Number4, '4'),
KEY_TRANS_ENTRY1(5, 5, 5, 5, '5', Number5, '5'),
KEY_TRANS_ENTRY1(6, 6, 6, 6, '6', Number6, '6'),
KEY_TRANS_ENTRY1(7, 7, 7, 7, '7', Number7, '7'),
KEY_TRANS_ENTRY1(8, 8, 8, 8, '8', Number8, '8'),
KEY_TRANS_ENTRY1(9, 9, 9, 9, '9', Number9, '9'),
KEY_TRANS_ENTRY1(0, 0, 0, 0, '0', Number0, '0'),
KEY_TRANS_ENTRY1(MINUS, MINUS, MINUS, MINUS, VK_OEM_MINUS, None, '-'),
KEY_TRANS_ENTRY1(EQUALS, EQUALS, EQUALS, EQUALS, VK_OEM_PLUS, None, '='),
KEY_TRANS_ENTRY1(BACKSPACE, BACKSPACE, BACKSPACE, BACK, VK_BACK, Back, 8),
KEY_TRANS_ENTRY1(TAB, TAB, TAB, TAB, VK_TAB, Tab, 9),
KEY_TRANS_ENTRY1(Q, Q, q, Q, 'Q', Q, 'Q'),
KEY_TRANS_ENTRY1(W, W, w, W, 'W', W, 'W'),
KEY_TRANS_ENTRY1(E, E, e, E, 'E', E, 'E'),
KEY_TRANS_ENTRY1(R, R, r, R, 'R', R, 'R'),
KEY_TRANS_ENTRY1(T, T, t, T, 'T', T, 'T'),
KEY_TRANS_ENTRY1(Y, Y, y, Y, 'Y', Y, 'Y'),
KEY_TRANS_ENTRY1(U, U, u, U, 'U', U, 'U'),
KEY_TRANS_ENTRY1(I, I, i, I, 'I', I, 'I'),
KEY_TRANS_ENTRY1(O, O, o, O, 'O', O, 'O'),
KEY_TRANS_ENTRY1(P, P, p, P, 'P', P, 'P'),
KEY_TRANS_ENTRY1(OPENBRACE, LEFTBRACKET, LEFTBRACKET, LBRACKET, VK_OEM_4, None, '['),
KEY_TRANS_ENTRY1(CLOSEBRACE, RIGHTBRACKET, RIGHTBRACKET, RBRACKET, VK_OEM_6, None, ']'),
KEY_TRANS_ENTRY0(ENTER, RETURN, RETURN, RETURN, VK_RETURN, Enter, 13, "RETURN"),
KEY_TRANS_ENTRY1(LCONTROL, LCTRL, LCTRL, LCONTROL, VK_LCONTROL, LeftControl, 0),
KEY_TRANS_ENTRY1(A, A, a, A, 'A', A, 'A'),
KEY_TRANS_ENTRY1(S, S, s, S, 'S', S, 'S'),
KEY_TRANS_ENTRY1(D, D, d, D, 'D', D, 'D'),
KEY_TRANS_ENTRY1(F, F, f, F, 'F', F, 'F'),
KEY_TRANS_ENTRY1(G, G, g, G, 'G', G, 'G'),
KEY_TRANS_ENTRY1(H, H, h, H, 'H', H, 'H'),
KEY_TRANS_ENTRY1(J, J, j, J, 'J', J, 'J'),
KEY_TRANS_ENTRY1(K, K, k, K, 'K', K, 'K'),
KEY_TRANS_ENTRY1(L, L, l, L, 'L', L, 'L'),
KEY_TRANS_ENTRY1(COLON, SEMICOLON, SEMICOLON, SEMICOLON, VK_OEM_1, None, ';'),
KEY_TRANS_ENTRY1(QUOTE, APOSTROPHE, QUOTE, APOSTROPHE, VK_OEM_7, None, '\''),
KEY_TRANS_ENTRY1(TILDE, GRAVE, BACKQUOTE, GRAVE, VK_OEM_3, None, '`'),
KEY_TRANS_ENTRY1(LSHIFT, LSHIFT, LSHIFT, LSHIFT, VK_LSHIFT, LeftShift, 0),
KEY_TRANS_ENTRY1(BACKSLASH, BACKSLASH, BACKSLASH, BACKSLASH, VK_OEM_5, None, '\\'),
// KEY_TRANS_ENTRY1(BACKSLASH2, NONUSHASH, UNKNOWN, OEM_102, VK_OEM_102, None, '<'),
// This is the additional key that ISO keyboards have over ANSI ones, located between left shift and Y.
KEY_TRANS_ENTRY1(BACKSLASH2, NONUSBACKSLASH, UNKNOWN, OEM_102, VK_OEM_102, '<'),
KEY_TRANS_ENTRY1(Z, Z, z, Z, 'Z', 'Z'),
KEY_TRANS_ENTRY1(X, X, x, X, 'X', 'X'),
KEY_TRANS_ENTRY1(C, C, c, C, 'C', 'C'),
KEY_TRANS_ENTRY1(V, V, v, V, 'V', 'V'),
KEY_TRANS_ENTRY1(B, B, b, B, 'B', 'B'),
KEY_TRANS_ENTRY1(N, N, n, N, 'N', 'N'),
KEY_TRANS_ENTRY1(M, M, m, M, 'M', 'M'),
KEY_TRANS_ENTRY1(COMMA, COMMA, COMMA, COMMA, VK_OEM_COMMA, ','),
KEY_TRANS_ENTRY1(STOP, PERIOD, PERIOD, PERIOD, VK_OEM_PERIOD, '.'),
KEY_TRANS_ENTRY1(SLASH, SLASH, SLASH, SLASH, VK_OEM_2, '/'),
KEY_TRANS_ENTRY1(RSHIFT, RSHIFT, RSHIFT, RSHIFT, VK_RSHIFT, 0),
KEY_TRANS_ENTRY1(ASTERISK, KP_MULTIPLY, KP_MULTIPLY, MULTIPLY, VK_MULTIPLY, '*'),
KEY_TRANS_ENTRY1(LALT, LALT, LALT, LMENU, VK_LMENU, 0),
KEY_TRANS_ENTRY1(SPACE, SPACE, SPACE, SPACE, VK_SPACE, ' '),
KEY_TRANS_ENTRY1(CAPSLOCK, CAPSLOCK, CAPSLOCK, CAPITAL, VK_CAPITAL, 0),
KEY_TRANS_ENTRY1(F1, F1, F1, F1, VK_F1, 0),
KEY_TRANS_ENTRY1(F2, F2, F2, F2, VK_F2, 0),
KEY_TRANS_ENTRY1(F3, F3, F3, F3, VK_F3, 0),
KEY_TRANS_ENTRY1(F4, F4, F4, F4, VK_F4, 0),
KEY_TRANS_ENTRY1(F5, F5, F5, F5, VK_F5, 0),
KEY_TRANS_ENTRY1(F6, F6, F6, F6, VK_F6, 0),
KEY_TRANS_ENTRY1(F7, F7, F7, F7, VK_F7, 0),
KEY_TRANS_ENTRY1(F8, F8, F8, F8, VK_F8, 0),
KEY_TRANS_ENTRY1(F9, F9, F9, F9, VK_F9, 0),
KEY_TRANS_ENTRY1(F10, F10, F10, F10, VK_F10, 0),
KEY_TRANS_ENTRY1(NUMLOCK, NUMLOCKCLEAR, NUMLOCKCLEAR, NUMLOCK, VK_NUMLOCK, 0),
KEY_TRANS_ENTRY1(SCRLOCK, SCROLLLOCK, SCROLLLOCK, SCROLL, VK_SCROLL, 0),
KEY_TRANS_ENTRY1(7_PAD, KP_7, KP_7, NUMPAD7, VK_NUMPAD7, 0),
KEY_TRANS_ENTRY1(8_PAD, KP_8, KP_8, NUMPAD8, VK_NUMPAD8, 0),
KEY_TRANS_ENTRY1(9_PAD, KP_9, KP_9, NUMPAD9, VK_NUMPAD9, 0),
KEY_TRANS_ENTRY1(MINUS_PAD, KP_MINUS, KP_MINUS, SUBTRACT, VK_SUBTRACT, 0),
KEY_TRANS_ENTRY1(4_PAD, KP_4, KP_4, NUMPAD4, VK_NUMPAD4, 0),
KEY_TRANS_ENTRY1(5_PAD, KP_5, KP_5, NUMPAD5, VK_NUMPAD5, 0),
KEY_TRANS_ENTRY1(6_PAD, KP_6, KP_6, NUMPAD6, VK_NUMPAD6, 0),
KEY_TRANS_ENTRY1(PLUS_PAD, KP_PLUS, KP_PLUS, ADD, VK_ADD, 0),
KEY_TRANS_ENTRY1(1_PAD, KP_1, KP_1, NUMPAD1, VK_NUMPAD1, 0),
KEY_TRANS_ENTRY1(2_PAD, KP_2, KP_2, NUMPAD2, VK_NUMPAD2, 0),
KEY_TRANS_ENTRY1(3_PAD, KP_3, KP_3, NUMPAD3, VK_NUMPAD3, 0),
KEY_TRANS_ENTRY1(0_PAD, KP_0, KP_0, NUMPAD0, VK_NUMPAD0, 0),
KEY_TRANS_ENTRY1(DEL_PAD, KP_PERIOD, KP_PERIOD, DECIMAL, VK_DECIMAL, 0),
KEY_TRANS_ENTRY1(F11, F11, F11, F11, VK_F11, 0),
KEY_TRANS_ENTRY1(F12, F12, F12, F12, VK_F12, 0),
KEY_TRANS_ENTRY1(F13, F13, F13, F13, VK_F13, 0),
KEY_TRANS_ENTRY1(F14, F14, F14, F14, VK_F14, 0),
KEY_TRANS_ENTRY1(F15, F15, F15, F15, VK_F15, 0),
KEY_TRANS_ENTRY1(ENTER_PAD, KP_ENTER, KP_ENTER, NUMPADENTER, VK_RETURN, 0),
KEY_TRANS_ENTRY1(RCONTROL, RCTRL, RCTRL, RCONTROL, VK_RCONTROL, 0),
KEY_TRANS_ENTRY1(SLASH_PAD, KP_DIVIDE, KP_DIVIDE, DIVIDE, VK_DIVIDE, 0),
KEY_TRANS_ENTRY1(PRTSCR, PRINTSCREEN, PRINTSCREEN, SYSRQ, 0, 0),
KEY_TRANS_ENTRY1(RALT, RALT, RALT, RMENU, VK_RMENU, 0),
KEY_TRANS_ENTRY1(HOME, HOME, HOME, HOME, VK_HOME, 0),
KEY_TRANS_ENTRY1(UP, UP, UP, UP, VK_UP, 0),
KEY_TRANS_ENTRY1(PGUP, PAGEUP, PAGEUP, PRIOR, VK_PRIOR, 0),
KEY_TRANS_ENTRY1(LEFT, LEFT, LEFT, LEFT, VK_LEFT, 0),
KEY_TRANS_ENTRY1(RIGHT, RIGHT, RIGHT, RIGHT, VK_RIGHT, 0),
KEY_TRANS_ENTRY1(END, END, END, END, VK_END, 0),
KEY_TRANS_ENTRY1(DOWN, DOWN, DOWN, DOWN, VK_DOWN, 0),
KEY_TRANS_ENTRY1(PGDN, PAGEDOWN, PAGEDOWN, NEXT, VK_NEXT, 0),
KEY_TRANS_ENTRY1(INSERT, INSERT, INSERT, INSERT, VK_INSERT, 0),
KEY_TRANS_ENTRY0(DEL, DELETE, DELETE, DELETE, VK_DELETE, 0, "DELETE"),
KEY_TRANS_ENTRY1(LWIN, LGUI, LGUI, LWIN, VK_LWIN, 0),
KEY_TRANS_ENTRY1(RWIN, RGUI, RGUI, RWIN, VK_RWIN, 0),
KEY_TRANS_ENTRY1(MENU, MENU, MENU, APPS, VK_APPS, 0),
KEY_TRANS_ENTRY1(PAUSE, PAUSE, PAUSE, PAUSE, VK_PAUSE, 0),
KEY_TRANS_ENTRY0(CANCEL, CANCEL, CANCEL, UNKNOWN, 0, 0, "CANCEL"),
KEY_TRANS_ENTRY1(BS_PAD, KP_BACKSPACE, KP_BACKSPACE, UNKNOWN, 0, 0),
KEY_TRANS_ENTRY1(TAB_PAD, KP_TAB, KP_TAB, UNKNOWN, 0, 0),
KEY_TRANS_ENTRY1(00_PAD, KP_00, KP_00, UNKNOWN, 0, 0),
KEY_TRANS_ENTRY1(000_PAD, KP_000, KP_000, UNKNOWN, 0, 0),
KEY_TRANS_ENTRY1(BACKSLASH2, NONUSBACKSLASH, UNKNOWN, OEM_102, VK_OEM_102, None, '<'),
KEY_TRANS_ENTRY1(Z, Z, z, Z, 'Z', Z, 'Z'),
KEY_TRANS_ENTRY1(X, X, x, X, 'X', X, 'X'),
KEY_TRANS_ENTRY1(C, C, c, C, 'C', C, 'C'),
KEY_TRANS_ENTRY1(V, V, v, V, 'V', V, 'V'),
KEY_TRANS_ENTRY1(B, B, b, B, 'B', B, 'B'),
KEY_TRANS_ENTRY1(N, N, n, N, 'N', N, 'N'),
KEY_TRANS_ENTRY1(M, M, m, M, 'M', M, 'M'),
KEY_TRANS_ENTRY1(COMMA, COMMA, COMMA, COMMA, VK_OEM_COMMA, None, ','),
KEY_TRANS_ENTRY1(STOP, PERIOD, PERIOD, PERIOD, VK_OEM_PERIOD, None, '.'),
KEY_TRANS_ENTRY1(SLASH, SLASH, SLASH, SLASH, VK_OEM_2, None, '/'),
KEY_TRANS_ENTRY1(RSHIFT, RSHIFT, RSHIFT, RSHIFT, VK_RSHIFT, RightShift, 0),
KEY_TRANS_ENTRY1(ASTERISK, KP_MULTIPLY, KP_MULTIPLY, MULTIPLY, VK_MULTIPLY, Multiply, '*'),
KEY_TRANS_ENTRY1(LALT, LALT, LALT, LMENU, VK_LMENU, LeftMenu, 0),
KEY_TRANS_ENTRY1(SPACE, SPACE, SPACE, SPACE, VK_SPACE, Space, ' '),
KEY_TRANS_ENTRY1(CAPSLOCK, CAPSLOCK, CAPSLOCK, CAPITAL, VK_CAPITAL, CapitalLock, 0),
KEY_TRANS_ENTRY1(F1, F1, F1, F1, VK_F1, F1, 0),
KEY_TRANS_ENTRY1(F2, F2, F2, F2, VK_F2, F2, 0),
KEY_TRANS_ENTRY1(F3, F3, F3, F3, VK_F3, F3, 0),
KEY_TRANS_ENTRY1(F4, F4, F4, F4, VK_F4, F4, 0),
KEY_TRANS_ENTRY1(F5, F5, F5, F5, VK_F5, F5, 0),
KEY_TRANS_ENTRY1(F6, F6, F6, F6, VK_F6, F6, 0),
KEY_TRANS_ENTRY1(F7, F7, F7, F7, VK_F7, F7, 0),
KEY_TRANS_ENTRY1(F8, F8, F8, F8, VK_F8, F8, 0),
KEY_TRANS_ENTRY1(F9, F9, F9, F9, VK_F9, F9, 0),
KEY_TRANS_ENTRY1(F10, F10, F10, F10, VK_F10, F10, 0),
KEY_TRANS_ENTRY1(NUMLOCK, NUMLOCKCLEAR, NUMLOCKCLEAR, NUMLOCK, VK_NUMLOCK, NumberKeyLock, 0),
KEY_TRANS_ENTRY1(SCRLOCK, SCROLLLOCK, SCROLLLOCK, SCROLL, VK_SCROLL, Scroll, 0),
KEY_TRANS_ENTRY1(7_PAD, KP_7, KP_7, NUMPAD7, VK_NUMPAD7, NumberPad7, 0),
KEY_TRANS_ENTRY1(8_PAD, KP_8, KP_8, NUMPAD8, VK_NUMPAD8, NumberPad8, 0),
KEY_TRANS_ENTRY1(9_PAD, KP_9, KP_9, NUMPAD9, VK_NUMPAD9, NumberPad9, 0),
KEY_TRANS_ENTRY1(MINUS_PAD, KP_MINUS, KP_MINUS, SUBTRACT, VK_SUBTRACT, Subtract, 0),
KEY_TRANS_ENTRY1(4_PAD, KP_4, KP_4, NUMPAD4, VK_NUMPAD4, NumberPad4, 0),
KEY_TRANS_ENTRY1(5_PAD, KP_5, KP_5, NUMPAD5, VK_NUMPAD5, NumberPad5, 0),
KEY_TRANS_ENTRY1(6_PAD, KP_6, KP_6, NUMPAD6, VK_NUMPAD6, NumberPad6, 0),
KEY_TRANS_ENTRY1(PLUS_PAD, KP_PLUS, KP_PLUS, ADD, VK_ADD, Add, 0),
KEY_TRANS_ENTRY1(1_PAD, KP_1, KP_1, NUMPAD1, VK_NUMPAD1, NumberPad1, 0),
KEY_TRANS_ENTRY1(2_PAD, KP_2, KP_2, NUMPAD2, VK_NUMPAD2, NumberPad2, 0),
KEY_TRANS_ENTRY1(3_PAD, KP_3, KP_3, NUMPAD3, VK_NUMPAD3, NumberPad3, 0),
KEY_TRANS_ENTRY1(0_PAD, KP_0, KP_0, NUMPAD0, VK_NUMPAD0, NumberPad0, 0),
KEY_TRANS_ENTRY1(DEL_PAD, KP_PERIOD, KP_PERIOD, DECIMAL, VK_DECIMAL, Decimal, 0),
KEY_TRANS_ENTRY1(F11, F11, F11, F11, VK_F11, F11, 0),
KEY_TRANS_ENTRY1(F12, F12, F12, F12, VK_F12, F12, 0),
KEY_TRANS_ENTRY1(F13, F13, F13, F13, VK_F13, F13, 0),
KEY_TRANS_ENTRY1(F14, F14, F14, F14, VK_F14, F14, 0),
KEY_TRANS_ENTRY1(F15, F15, F15, F15, VK_F15, F15, 0),
KEY_TRANS_ENTRY1(ENTER_PAD, KP_ENTER, KP_ENTER, NUMPADENTER, VK_RETURN, None, 0),
KEY_TRANS_ENTRY1(RCONTROL, RCTRL, RCTRL, RCONTROL, VK_RCONTROL, RightControl, 0),
KEY_TRANS_ENTRY1(SLASH_PAD, KP_DIVIDE, KP_DIVIDE, DIVIDE, VK_DIVIDE, Divide, 0),
KEY_TRANS_ENTRY1(PRTSCR, PRINTSCREEN, PRINTSCREEN, SYSRQ, 0, Print, 0),
KEY_TRANS_ENTRY1(RALT, RALT, RALT, RMENU, VK_RMENU, RightMenu, 0),
KEY_TRANS_ENTRY1(HOME, HOME, HOME, HOME, VK_HOME, Home, 0),
KEY_TRANS_ENTRY1(UP, UP, UP, UP, VK_UP, Up, 0),
KEY_TRANS_ENTRY1(PGUP, PAGEUP, PAGEUP, PRIOR, VK_PRIOR, PageUp, 0),
KEY_TRANS_ENTRY1(LEFT, LEFT, LEFT, LEFT, VK_LEFT, Left, 0),
KEY_TRANS_ENTRY1(RIGHT, RIGHT, RIGHT, RIGHT, VK_RIGHT, Right, 0),
KEY_TRANS_ENTRY1(END, END, END, END, VK_END, End, 0),
KEY_TRANS_ENTRY1(DOWN, DOWN, DOWN, DOWN, VK_DOWN, Down, 0),
KEY_TRANS_ENTRY1(PGDN, PAGEDOWN, PAGEDOWN, NEXT, VK_NEXT, PageDown, 0),
KEY_TRANS_ENTRY1(INSERT, INSERT, INSERT, INSERT, VK_INSERT, Insert, 0),
KEY_TRANS_ENTRY0(DEL, DELETE, DELETE, DELETE, VK_DELETE, Delete, 0, "DELETE"),
KEY_TRANS_ENTRY1(LWIN, LGUI, LGUI, LWIN, VK_LWIN, LeftWindows, 0),
KEY_TRANS_ENTRY1(RWIN, RGUI, RGUI, RWIN, VK_RWIN, RightWindows, 0),
KEY_TRANS_ENTRY1(MENU, MENU, MENU, APPS, VK_APPS, Menu, 0),
KEY_TRANS_ENTRY1(PAUSE, PAUSE, PAUSE, PAUSE, VK_PAUSE, Pause, 0),
KEY_TRANS_ENTRY0(CANCEL, CANCEL, CANCEL, UNKNOWN, 0, Cancel, 0, "CANCEL"),
KEY_TRANS_ENTRY1(BS_PAD, KP_BACKSPACE, KP_BACKSPACE, UNKNOWN, 0, None, 0),
KEY_TRANS_ENTRY1(TAB_PAD, KP_TAB, KP_TAB, UNKNOWN, 0, None, 0),
KEY_TRANS_ENTRY1(00_PAD, KP_00, KP_00, UNKNOWN, 0, None, 0),
KEY_TRANS_ENTRY1(000_PAD, KP_000, KP_000, UNKNOWN, 0, None, 0),
// New keys introduced in Windows 2000. These have no MAME codes to
// preserve compatibility with old config files that may refer to them
@ -167,19 +170,19 @@ key_trans_entry keyboard_trans_table::s_default_table[] =
// GetAsyncKeyState polling is used (as happens currently when MAME is
// paused). Some codes are missing because the mapping to vkey codes
// isn't clear, and MapVirtualKey is no help.
KEY_TRANS_ENTRY1(OTHER_SWITCH, MUTE, MUTE, MUTE, VK_VOLUME_MUTE, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, VOLUMEDOWN, VOLUMEDOWN, VOLUMEDOWN, VK_VOLUME_DOWN, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, VOLUMEUP, VOLUMEUP, VOLUMEUP, VK_VOLUME_UP, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_HOME, AC_HOME, WEBHOME, VK_BROWSER_HOME, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_SEARCH, AC_SEARCH, WEBSEARCH, VK_BROWSER_SEARCH, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_BOOKMARKS, AC_BOOKMARKS, WEBFAVORITES, VK_BROWSER_FAVORITES, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_REFRESH, AC_REFRESH, WEBREFRESH, VK_BROWSER_REFRESH, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_STOP, AC_STOP, WEBSTOP, VK_BROWSER_STOP, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_FORWARD, AC_FORWARD, WEBFORWARD, VK_BROWSER_FORWARD, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_BACK, AC_BACK, WEBBACK, VK_BROWSER_BACK, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, MAIL, MAIL, MAIL, VK_LAUNCH_MAIL, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, MEDIASELECT, MEDIASELECT, MEDIASELECT, VK_LAUNCH_MEDIA_SELECT, 0),
KEY_TRANS_ENTRY0(INVALID, UNKNOWN, UNKNOWN, ESCAPE, 0, 0, "INVALID")
KEY_TRANS_ENTRY1(OTHER_SWITCH, MUTE, MUTE, MUTE, VK_VOLUME_MUTE, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, VOLUMEDOWN, VOLUMEDOWN, VOLUMEDOWN, VK_VOLUME_DOWN, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, VOLUMEUP, VOLUMEUP, VOLUMEUP, VK_VOLUME_UP, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_HOME, AC_HOME, WEBHOME, VK_BROWSER_HOME, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_SEARCH, AC_SEARCH, WEBSEARCH, VK_BROWSER_SEARCH, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_BOOKMARKS, AC_BOOKMARKS, WEBFAVORITES, VK_BROWSER_FAVORITES, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_REFRESH, AC_REFRESH, WEBREFRESH, VK_BROWSER_REFRESH, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_STOP, AC_STOP, WEBSTOP, VK_BROWSER_STOP, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_FORWARD, AC_FORWARD, WEBFORWARD, VK_BROWSER_FORWARD, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, AC_BACK, AC_BACK, WEBBACK, VK_BROWSER_BACK, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, MAIL, MAIL, MAIL, VK_LAUNCH_MAIL, None, 0),
KEY_TRANS_ENTRY1(OTHER_SWITCH, MEDIASELECT, MEDIASELECT, MEDIASELECT, VK_LAUNCH_MEDIA_SELECT, None, 0),
KEY_TRANS_ENTRY0(INVALID, UNKNOWN, UNKNOWN, ESCAPE, 0, None, 0, "INVALID")
};
// The private constructor to create the default instance
@ -259,6 +262,21 @@ int keyboard_trans_table::vkey_for_mame_code(input_code code) const
return 0;
}
#elif defined(OSD_UWP)
input_item_id keyboard_trans_table::map_vkey_to_itemid(Windows::System::VirtualKey vkey) const
{
int tablenum;
// scan the table for a match
for (tablenum = 0; tablenum < m_table_size; tablenum++)
if (m_table[tablenum].virtual_key == vkey)
return m_table[tablenum].mame_key;
// default to an "other" switch
return ITEM_ID_OTHER_SWITCH;
}
#endif

8
src/osd/modules/input/input_common.h
View File

@ -352,12 +352,14 @@ public:
struct key_trans_entry {
input_item_id mame_key;
#if !defined(OSD_WINDOWS)
#if defined(OSD_SDL)
int sdl_scancode;
int sdl_key;
#else
#elif defined(OSD_WINDOWS)
int scan_code;
unsigned char virtual_key;
#elif defined(OSD_UWP)
Windows::System::VirtualKey virtual_key;
#endif
char ascii_key;
@ -391,6 +393,8 @@ public:
#if defined(OSD_WINDOWS)
input_item_id map_di_scancode_to_itemid(int di_scancode) const;
int vkey_for_mame_code(input_code code) const;
#elif defined(OSD_UWP)
input_item_id map_vkey_to_itemid(Windows::System::VirtualKey vkey) const;
#endif
static keyboard_trans_table& instance()

161
src/osd/modules/input/input_uwp.cpp Normal file
View File

@ -0,0 +1,161 @@
// license:BSD-3-Clause
// copyright-holders:Brad Hughes
//============================================================
//
// input_uwp.cpp - UWP input implementation
//
//============================================================
#include "input_module.h"
#include "modules/osdmodule.h"
#if defined(OSD_UWP)
#include <agile.h>
#include <ppltasks.h>
#include <collection.h>
#undef min
#undef max
#undef interface
// MAME headers
#include "emu.h"
#include "uiinput.h"
// MAMEOS headers
#include "winmain.h"
#include "input_common.h"
#include "input_windows.h"
using namespace concurrency;
using namespace Windows::UI::Core;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
// This device is purely event driven so the implementation is in the module
class uwp_keyboard_device : public event_based_device<KeyPressEventArgs>
{
public:
keyboard_state keyboard;
uwp_keyboard_device(running_machine& machine, const char *name, const char *id, input_module &module)
: event_based_device(machine, name, id, DEVICE_CLASS_KEYBOARD, module),
keyboard({{0}})
{
}
void reset() override
{
memset(&keyboard, 0, sizeof(keyboard));
}
protected:
void process_event(KeyPressEventArgs &args) override
{
keyboard.state[args.vkey] = args.event_id == INPUT_EVENT_KEYDOWN ? 0x80 : 0x00;
}
};
private ref class key_processor sealed
{
private:
Platform::Agile<CoreWindow^> m_window;
input_device_list &m_devicelist;
running_machine &m_machine;
internal:
key_processor(CoreWindow^ window, input_device_list &devicelist, running_machine &machine)
: m_window(window),
m_devicelist(devicelist),
m_machine(machine)
{
m_window->KeyDown += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &key_processor::OnKeyDown);
m_window->KeyUp += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &key_processor::OnKeyUp);
m_window->CharacterReceived += ref new TypedEventHandler<CoreWindow^, CharacterReceivedEventArgs^>(this, &key_processor::OnCharacterReceived);
}
void OnKeyDown(CoreWindow^ win, KeyEventArgs^ args)
{
auto &table = keyboard_trans_table::instance();
//if (args->VirtualKey < Windows::System::VirtualKey::Space)
// m_machine.ui_input().push_char_event(osd_common_t::s_window_list.front()->target(), static_cast<char32_t>(args->VirtualKey));
KeyPressEventArgs tmp;
tmp.event_id = INPUT_EVENT_KEYDOWN;
tmp.vkey = uint8_t(args->VirtualKey);
m_devicelist.for_each_device([&tmp](device_info *device)
{
static_cast<uwp_keyboard_device*>(device)->queue_events(&tmp, 1);
});
}
void OnKeyUp(CoreWindow^ win, KeyEventArgs^ args)
{
KeyPressEventArgs tmp;
tmp.event_id = INPUT_EVENT_KEYUP;
tmp.vkey = uint8_t(args->VirtualKey);
m_devicelist.for_each_device([&tmp](device_info *device)
{
static_cast<uwp_keyboard_device*>(device)->queue_events(&tmp, 1);
});
}
void OnCharacterReceived(CoreWindow ^sender, CharacterReceivedEventArgs ^args)
{
m_machine.ui_input().push_char_event(osd_common_t::s_window_list.front()->target(), args->KeyCode);
}
};
//============================================================
// uwp_keyboard_module
//============================================================
class uwp_keyboard_module : public wininput_module
{
private:
key_processor^ m_key_processor;
public:
uwp_keyboard_module()
: wininput_module(OSD_KEYBOARDINPUT_PROVIDER, "uwp"),
m_key_processor(nullptr)
{
}
virtual void input_init(running_machine &machine) override
{
auto first_window = std::static_pointer_cast<uwp_window_info>(osd_common_t::s_window_list.front());
m_key_processor = ref new key_processor(first_window->uwp_window(), *devicelist(), machine);
// Add a single UWP keyboard device
uwp_keyboard_device *devinfo = devicelist()->create_device<uwp_keyboard_device>(machine, "UWP Keyboard 1", "UWP Keyboard 1", *this);
keyboard_trans_table &table = keyboard_trans_table::instance();
// populate it
for (int keynum = 0; keynum < MAX_KEYS; keynum++)
{
input_item_id itemid = table.map_vkey_to_itemid(Windows::System::VirtualKey(keynum));
char name[20];
// generate/fetch the name
_snprintf(name, ARRAY_LENGTH(name), "Scan%03d", keynum);
// add the item to the device
devinfo->device()->add_item(name, itemid, generic_button_get_state<std::uint8_t>, &devinfo->keyboard.state[keynum]);
}
}
void exit() override
{
m_key_processor = nullptr;
}
};
#else
MODULE_NOT_SUPPORTED(uwp_keyboard_module, OSD_KEYBOARDINPUT_PROVIDER, "uwp")
#endif
MODULE_DEFINITION(KEYBOARDINPUT_UWP, uwp_keyboard_module)

10
src/osd/modules/lib/osdlib_uwp.cpp
View File

@ -270,17 +270,17 @@ void *PeGetProcAddressA(void *Base, LPCSTR Name)
{
for (DWORD i = 0; i<Exp->NumberOfNames && Ret == 0; i++)
{
char *Func = (char*)(Names[i] + (DWORD_PTR)Base);
char *Func = (char*)(Names[i] + std::uintptr_t(Base));
if (Func && strcmp(Func, Name) == 0)
Ret = (FARPROC)(Functions[Ordinals[i]] + (DWORD_PTR)Base);
Ret = (FARPROC)(Functions[Ordinals[i]] + std::uintptr_t(Base));
}
}
if (Ret)
{
DWORD ExpStart = NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (DWORD)Base;
DWORD ExpSize = NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
if ((DWORD)Ret >= ExpStart && (DWORD)Ret <= ExpStart + ExpSize)
std::uintptr_t ExpStart = NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + std::uintptr_t(Base);
std::uintptr_t ExpSize = NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
if (std::uintptr_t(Ret) >= ExpStart && std::uintptr_t(Ret) <= ExpStart + ExpSize)
{
// Forwarder
return 0;

1
src/osd/modules/lib/osdobj_common.cpp
View File

@ -242,6 +242,7 @@ void osd_common_t::register_options()
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_RAWINPUT);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_DINPUT);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_WIN32);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_UWP);
REGISTER_MODULE(m_mod_man, KEYBOARD_NONE);
REGISTER_MODULE(m_mod_man, MOUSEINPUT_SDL);

36
src/osd/uwp/window.cpp
View File

@ -328,32 +328,6 @@ BOOL winwindow_has_focus(void)
return TRUE;
}
inline static BOOL handle_mouse_button(windows_osd_interface *osd, int button, int down, int x, int y)
{
MouseButtonEventArgs args;
args.button = button;
args.keydown = down;
args.xpos = x;
args.ypos = y;
bool handled = osd->handle_input_event(INPUT_EVENT_MOUSE_BUTTON, &args);
// When in lightgun mode or mouse mode, the mouse click may be routed to the input system
// because the mouse interactions in the UI are routed from the video_window_proc below
// we need to make sure they aren't suppressed in these cases.
return handled && !osd->options().lightgun() && !osd->options().mouse();
}
inline static BOOL handle_keypress(windows_osd_interface *osd, int vkey, int down, int scancode, BOOL extended_key)
{
KeyPressEventArgs args;
args.event_id = down ? INPUT_EVENT_KEYDOWN : INPUT_EVENT_KEYUP;
args.scancode = MAKE_DI_SCAN(scancode, extended_key);
args.vkey = vkey;
return osd->handle_input_event(args.event_id, &args);
}
//============================================================
// winwindow_process_events
// (main thread)
@ -368,7 +342,15 @@ void winwindow_process_events(running_machine &machine, bool ingame, bool nodisp
// remember the last time we did this
last_event_check = std::chrono::system_clock::now();
CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
try
{
CoreWindow^ window = CoreWindow::GetForCurrentThread();
window->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
}
catch (Platform::DisconnectedException^)
{
// This can get thrown when the window is being destroyed
}
}