From 61858c4d620a7570f3690eff72594b66a64514ec Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Fri, 8 Feb 2019 00:13:09 -0500 Subject: [PATCH 1/9] Add Low-Level hook for Windows keyboard events windows, alt, and control keys are handled separately, before windows can get a chance to act on them. This makes win usable as an option key and prevents things like alt-esc from minimizing the window. Some combos (alt-control-delete, windows-L, etc) cannot be blocked. --- src/win_console.c | 4 ++++ src/win_generic.c | 43 ++++++++++++++++++++++++++++++++++++++----- src/win_keymap.h | 39 ++++++++++++++++++++++++--------------- 3 files changed, 66 insertions(+), 20 deletions(-) diff --git a/src/win_console.c b/src/win_console.c index 000aed6..983e6a6 100644 --- a/src/win_console.c +++ b/src/win_console.c @@ -112,6 +112,7 @@ int main(int argc, char **argv) { WNDCLASS wndclass; SIZE size; RECT rect; + HHOOK hook; wndclass.style = 0; wndclass.lpfnWndProc = (WNDPROC)win_event_handler; @@ -151,9 +152,12 @@ int main(int argc, char **argv) { SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), mode); + hook = SetWindowsHookEx(WH_KEYBOARD_LL, win_ll_keyboard, NULL, 0); + gsportinit(hwnd); int ret = gsplusmain(argc, argv); + UnhookWindowsHookEx(hook); UnregisterClass(wndclass.lpszClassName,GetModuleHandle(NULL)); gsportshut(); diff --git a/src/win_generic.c b/src/win_generic.c index 5c680e0..ee2a0c0 100644 --- a/src/win_generic.c +++ b/src/win_generic.c @@ -226,11 +226,6 @@ void win_event_key(HWND hwnd, UINT raw_vk, BOOL down, int repeat, UINT flags) vk, down, repeat, flags); #endif - /* remap a few keys here.. sigh */ - if((vk & 0xff) == VK_APPS) { - /* remap to command */ - vk = VK_MENU; - } if((vk & 0xff) == VK_CAPITAL) { // Windows gives us up-and-down events of the actual key @@ -260,6 +255,44 @@ void win_event_key(HWND hwnd, UINT raw_vk, BOOL down, int repeat, UINT flags) printf("VK: %04x unknown\n", vk); } +/* low-level hook for keyboard events, to bypass special handling of + * windows key, alt-escape, etc + */ +LRESULT CALLBACK win_ll_keyboard(int nCode, WPARAM wParam, LPARAM lParam) { + KBDLLHOOKSTRUCT *kb = (KBDLLHOOKSTRUCT *)lParam; + int down = 0; + + if (nCode < 0 || GetFocus() == NULL) return CallNextHookEx(0, nCode, wParam, lParam); + + if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) down = 1; + + switch (kb->vkCode) { + case VK_LWIN: + case VK_RWIN: + case VK_MENU: + case VK_LMENU: + case VK_RMENU: + case VK_CONTROL: + case VK_LCONTROL: + case VK_RCONTROL: + if (nb_win32_key < MAX_EVENT) { + + win32_keys[nb_win32_key].raw_vk = kb->vkCode; + win32_keys[nb_win32_key].down = down; + win32_keys[nb_win32_key].repeat = 0; + win32_keys[nb_win32_key].flags = kb->flags; /* same? */ + + nb_win32_key++; + } + return 1; + break; + } + + return CallNextHookEx(0, nCode, wParam, lParam); +} + + + void win_event_quit(HWND hwnd) { quitEmulator(); } diff --git a/src/win_keymap.h b/src/win_keymap.h index 00b8d59..202c9c4 100644 --- a/src/win_keymap.h +++ b/src/win_keymap.h @@ -4,7 +4,7 @@ int g_a2_key_to_wsym[][3] = { { 0x35, VK_ESCAPE, 0 }, { 0x7a, VK_F1, 0 }, - { 0x78, VK_F2, 0 }, // OG Was 7B but F2 is defined has 0x78 in a2_key_to_ascii + { 0x78, VK_F2, 0 }, { 0x63, VK_F3, 0 }, { 0x76, VK_F4, 0 }, { 0x60, VK_F5, 0 }, @@ -18,7 +18,9 @@ int g_a2_key_to_wsym[][3] = { { 0x69, VK_F13, 0 }, { 0x6b, VK_F14, 0 }, { 0x71, VK_F15, 0 }, - { 0x7f, VK_PAUSE, VK_CANCEL+0x100 }, + + { 0x7f, VK_PAUSE, VK_PAUSE+0x100 }, + { 0x7f, VK_CANCEL, VK_CANCEL+0x100 }, { 0x32, 0xc0, 0 }, /* '`' */ { 0x12, '1', 0 }, @@ -35,10 +37,9 @@ int g_a2_key_to_wsym[][3] = { { 0x18, 0xbb, 0 }, /* '=' */ { 0x33, VK_BACK, 0 }, /* backspace */ { 0x72, VK_INSERT+0x100, 0 }, /* Insert key */ -/* { 0x73, XK_Home, 0 }, alias VK_HOME to be KP_Equal! */ { 0x74, VK_PRIOR+0x100, 0 }, /* pageup */ { 0x47, VK_NUMLOCK, VK_NUMLOCK+0x100 }, /* clear */ - { 0x51, VK_HOME+0x100, 0 }, /* KP_equal is HOME key */ + { 0x51, VK_HOME+0x100, 0 }, { 0x4b, VK_DIVIDE, VK_DIVIDE+0x100 }, { 0x43, VK_MULTIPLY, VK_MULTIPLY+0x100 }, @@ -83,6 +84,8 @@ int g_a2_key_to_wsym[][3] = { { 0x45, VK_ADD, 0 }, { 0x38, VK_SHIFT, 0 }, + { 0x38, VK_LSHIFT, 0 }, + { 0x38, VK_RSHIFT, 0 }, { 0x06, 'Z', 0 }, { 0x07, 'X', 0 }, { 0x08, 'C', 0 }, @@ -99,18 +102,24 @@ int g_a2_key_to_wsym[][3] = { { 0x55, VK_NUMPAD3, VK_NEXT }, { 0x36, VK_CONTROL, VK_CONTROL+0x100 }, - { 0x3a, VK_SNAPSHOT+0x100, VK_MENU+0x100 },/* Opt=prntscrn or alt-r */ + { 0x36, VK_LCONTROL, VK_LCONTROL+0x100 }, + { 0x36, VK_RCONTROL, VK_RCONTROL+0x100 }, + { 0x3a, VK_SNAPSHOT+0x100, 0 },/* Opt=prntscrn or alt-r */ -// OG ActiveGS map OA-CA to Win & AltKey -#ifndef ACTIVEGS - { 0x37, VK_SCROLL, VK_MENU }, /* Command=scr_lock or alt-l */ -#else - { 0x7f, VK_CANCEL, 0 }, - { 0x3A, VK_LWIN+0x100, VK_LWIN }, - { 0x37, VK_MENU, 0 }, /* Command=alt-l */ - { 0x37, VK_LMENU, 0 }, /* Command=alt-l */ + /* LMENU/RMENU = alt key = command*/ + /* LWIN / RWIN = windows key = option */ + /* weird menu key = APPS = option */ + + { 0x3A, VK_LWIN, VK_LWIN+0x100 }, + { 0x3A, VK_RWIN, VK_RWIN+0x100 }, + { 0x3A, VK_APPS, VK_APPS+0x100 }, + { 0x37, VK_MENU, VK_MENU+0x100 }, + { 0x37, VK_LMENU, VK_LMENU+0x100 }, + { 0x37, VK_RMENU, VK_RMENU+0x100 }, + + +#ifdef ACTIVEGS { 0x7F, VK_SCROLL,0 }, /* RESET */ - { 0x36, VK_LCONTROL, 0 }, // CTRL #endif { 0x31, ' ', 0 }, @@ -118,7 +127,7 @@ int g_a2_key_to_wsym[][3] = { { 0x3d, VK_DOWN+0x100, 0 }, { 0x3c, VK_RIGHT+0x100, 0 }, { 0x52, VK_NUMPAD0, VK_INSERT }, - { 0x41, VK_DECIMAL, VK_DECIMAL }, + { 0x41, VK_DECIMAL, VK_DELETE }, { 0x4c, VK_RETURN+0x100, 0 }, { -1, -1, -1 } }; From 86285cc43d76e7e170fff66cc38412e629459571 Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 17 Feb 2019 14:15:13 -0500 Subject: [PATCH 2/9] replace hard coded ADB keycode with nice enums. There are also a couple fixes in the SDL keymap (home key, {, }, keypad numbers) xdriver isn't updated because I don't care about x. win32 driver isn't updated pending other win32 keymap patch. --- src/adb.c | 63 ++++++++----- src/adb.h | 62 ++++++------- src/adb_keycodes.h | 189 ++++++++++++++++++++++++++++++++++++++ src/sdl2_driver.c | 224 ++++++++++++++++++++++++--------------------- 4 files changed, 380 insertions(+), 158 deletions(-) create mode 100644 src/adb_keycodes.h diff --git a/src/adb.c b/src/adb.c index 0bce5f2..bd1c28c 100644 --- a/src/adb.c +++ b/src/adb.c @@ -10,6 +10,9 @@ #include "adb.h" #include "glog.h" +#include "adb_keycodes.h" + + int g_fullscreen = 0; int g_grabmouse = 0; @@ -1655,34 +1658,48 @@ void adb_physical_key_update(int a2code, int is_up) { /* Now check for special keys (function keys, etc) */ ascii_and_type = a2_key_to_ascii[a2code][1]; special = 0; - if((ascii_and_type & 0xf000) == 0x8000) { - /* special function key */ + + /* special FKeys? */ + if (ascii_and_type & 0x1000) { special = ascii_and_type & 0xff; - switch(special) { - case 0x01: /* F1 - remap to cmd */ - a2code = 0x37; + switch (special) { + case kVK_F1: + /* F1 - remap to cmd */ + a2code = kVK_Command; special = 0; break; - case 0x02: /* F2 - remap to option */ - a2code = 0x3a; + case kVK_F2: + /* F2 - remap to option */ + a2code = kVK_Option; special = 0; break; - case 0x0c: /* F12 - remap to reset */ - a2code = 0x7f; + case kVK_F12: + /* F12 - remap to reset */ + a2code = kVK_Reset; special = 0; break; + case kVK_F3: + case kVK_F4: + case kVK_F5: + case kVK_F6: + case kVK_F7: + case kVK_F8: + case kVK_F9: + case kVK_F10: + case kVK_F11: + break; default: - break; + special = 0; } } /* CUA clipboard paste - for those that remember ctrl-insert/shift-insert */ - if(is_up == 0 && a2code == 0x72 && SHIFT_DOWN) { + if(is_up == 0 && a2code == kVK_Insert && SHIFT_DOWN) { clipboard_paste(); } /* Only process reset requests here */ - if(is_up == 0 && a2code == 0x7f && CTRL_DOWN) { + if(is_up == 0 && a2code == kVK_Reset && CTRL_DOWN) { /* Reset pressed! */ glogf("Reset pressed since CTRL_DOWN: %d", CTRL_DOWN); do_reset(); @@ -1691,10 +1708,10 @@ void adb_physical_key_update(int a2code, int is_up) { if(special && !is_up) { switch(special) { - case 0x03: /* F3 - screenshot */ + case kVK_F3: /* F3 - screenshot */ g_screenshot_requested = 1; break; - case 0x04: /* F4 - emulator config panel */ + case kVK_F4: /* F4 - emulator config panel */ if (CMD_DOWN) { glog("Alt-F4 Quit!"); iwm_shut(); @@ -1705,7 +1722,7 @@ void adb_physical_key_update(int a2code, int is_up) { cfg_toggle_config_panel(); } break; - case 0x05: /* F5 - emulator clipboard paste */ + case kVK_F5: /* F5 - emulator clipboard paste */ if (SHIFT_DOWN) { g_grabmouse = !g_grabmouse; #ifdef HAVE_SDL @@ -1717,18 +1734,18 @@ void adb_physical_key_update(int a2code, int is_up) { clipboard_paste(); } break; - case 0x06: /* F6 - emulator speed */ + case kVK_F6: /* F6 - emulator speed */ if(SHIFT_DOWN) { halt2_printf("Shift-F6 pressed\n"); } else { adb_increment_speed(); } break; - case 0x07: /* F7 - fast disk emul */ + case kVK_F7: /* F7 - fast disk emul */ g_fast_disk_emul = !g_fast_disk_emul; glogf("g_fast_disk_emul is now %d", g_fast_disk_emul); break; - case 0x08: /* F8 - warp pointer */ + case kVK_F8: /* F8 - warp pointer */ g_warp_pointer = !g_warp_pointer; if(g_hide_pointer != g_warp_pointer) { g_hide_pointer = g_warp_pointer; @@ -1736,7 +1753,7 @@ void adb_physical_key_update(int a2code, int is_up) { } glogf("g_warp_pointer is now %d", g_warp_pointer); break; - case 0x09: /* F9 - swap paddles */ + case kVK_F9: /* F9 - swap paddles */ if(SHIFT_DOWN) { g_swap_paddles = !g_swap_paddles; glogf("Swap paddles is now: %d", g_swap_paddles); @@ -1745,7 +1762,7 @@ void adb_physical_key_update(int a2code, int is_up) { glogf("Invert paddles is now: %d", g_invert_paddles); } break; - case 0x0a: /* F10 - change a2vid paletter */ + case kVK_F10: /* F10 - change a2vid paletter */ if (SHIFT_DOWN) { #ifdef TOGGLE_STATUS extern void x_toggle_status_lines(); @@ -1758,7 +1775,7 @@ void adb_physical_key_update(int a2code, int is_up) { change_a2vid_palette((g_a2vid_palette + 1) & 0xf); } break; - case 0x0b: /* F11 - full screen */ + case kVK_F11: /* F11 - full screen */ g_fullscreen = !g_fullscreen; x_full_screen(g_fullscreen); break; @@ -1780,10 +1797,10 @@ void adb_physical_key_update(int a2code, int is_up) { /* keypress pass on further, except for cmd/opt */ if(ascii == 0x30) { /* remap '0' to cmd */ - a2code = 0x37; + a2code = kVK_Command; } else if(ascii == 0x2e || ascii == 0x2c) { /* remap '.' and ',' to option */ - a2code = 0x3a; + a2code = kVK_Option; } else { /* Just ignore it in this mode */ return; diff --git a/src/adb.h b/src/adb.h index 2c2e7c7..41005ea 100644 --- a/src/adb.h +++ b/src/adb.h @@ -79,10 +79,10 @@ const int a2_key_to_ascii[][4] = { { 0x3c, 0x15, 0x15, -1 }, /* right */ { 0x3d, 0x0a, 0x0a, -1 }, /* down */ { 0x3e, 0x0b, 0x0b, -1 }, /* up arrow */ - { 0x3f, -1, -1, -1 }, + { 0x3f, 0x103f, 0x103f, -1 }, /* function key */ - { 0x40, -1, -1, -1 }, - { 0x41, 0x102e, 0x102c, -1 }, /* keypad . */ + { 0x40, 0x1040, 0x1040, -1 }, /* F17 */ + { 0x41, 0x102e, 0x102e, -1 }, /* keypad . */ { 0x42, -1, -1, -1 }, { 0x43, 0x102a, 0x102a, -1 }, /* keypad * */ { 0x44, -1, -1, -1 }, @@ -90,16 +90,16 @@ const int a2_key_to_ascii[][4] = { { 0x46, -1, -1, -1 }, { 0x47, 0x1018, 0x1018, -1 }, /* keypad Clear */ - { 0x48, -1, -1, -1 }, - { 0x49, -1, -1, -1 }, - { 0x4a, -1, -1, -1 }, + { 0x48, 0x1048, 0x1048, -1 }, /* volume up */ + { 0x49, 0x1049, 0x1049, -1 }, /* volume down */ + { 0x4a, 0x104a, 0x104a, -1 }, /* mute */ { 0x4b, 0x102f, 0x102f, -1 }, /* keypad / */ { 0x4c, 0x100d, 0x100d, -1 }, /* keypad enter */ { 0x4d, -1, -1, -1 }, { 0x4e, 0x102d, 0x102d, -1 }, /* keypad - */ - { 0x4f, -1, -1, -1 }, + { 0x4f, 0x104f, 0x104f, -1 }, /* F18 */ - { 0x50, -1, -1, -1 }, + { 0x50, 0x1050, 0x1050, -1 }, /* F19 */ { 0x51, 0x103d, 0x103d, -1 }, /* keypad = */ { 0x52, 0x1030, 0x1030, -1 }, /* keypad 0 */ { 0x53, 0x1031, 0x1031, -1 }, /* keypad 1 */ @@ -110,48 +110,46 @@ const int a2_key_to_ascii[][4] = { { 0x58, 0x1036, 0x1036, -1 }, /* keypad 6 */ { 0x59, 0x1037, 0x1037, -1 }, /* keypad 7 */ - { 0x5a, 'a', 'A', 0x01 }, /* probably not necessary */ + { 0x5a, 0x105a, 0x105a, -1 }, /* F20 */ { 0x5b, 0x1038, 0x1038, -1 }, /* keypad 8 */ { 0x5c, 0x1039, 0x1039, -1 }, /* keypad 9 */ { 0x5d, -1, -1, -1 }, { 0x5e, -1, -1, -1 }, { 0x5f, -1, -1, -1 }, - { 0x60, 0x8005, 0x1060, -1 }, /* F5 */ - { 0x61, 0x8006, 0x1061, -1 }, /* F6 */ - { 0x62, 0x8007, 0x1062, -1 }, /* F7 */ - { 0x63, 0x8003, 0x1063, -1 }, /* F3 */ - { 0x64, 0x8008, 0x1064, -1 }, /* F8 */ - { 0x65, 0x8009, 0x1065, -1 }, /* F9 */ + { 0x60, 0x1060, 0x1060, -1 }, /* F5 */ + { 0x61, 0x1061, 0x1061, -1 }, /* F6 */ + { 0x62, 0x1062, 0x1062, -1 }, /* F7 */ + { 0x63, 0x1063, 0x1063, -1 }, /* F3 */ + { 0x64, 0x1064, 0x1064, -1 }, /* F8 */ + { 0x65, 0x1065, 0x1065, -1 }, /* F9 */ { 0x66, -1, -1, -1 }, - { 0x67, 0x800b, 0x1067, -1 }, /* F11 */ + { 0x67, 0x1067, 0x1067, -1 }, /* F11 */ { 0x68, -1, -1, -1 }, -// { 0x69, 0x800d, 0x1069, -1 }, /* F13 */ -// OG remap F13 to reset - { 0x69, 0x800c, 0x1069, -1 }, /* F13 */ - { 0x6a, -1, -1, -1 }, - { 0x6b, 0x800e, 0x106b, -1 }, /* F14 */ + { 0x69, 0x1069, 0x1069, -1 }, /* F13 */ + { 0x6a, 0x106a, 0x106a, -1 }, /* F16 */ + { 0x6b, 0x106b, 0x106b, -1 }, /* F14 */ { 0x6c, -1, -1, -1 }, - { 0x6d, 0x800a, 0x106d, -1 }, /* F10 */ - { 0x6e, 0x4000, 0x4000, -1 }, /* windows key alias to option */ - { 0x6f, 0x800c, 0x106f, -1 }, /* F12 */ + { 0x6d, 0x106d, 0x106d, -1 }, /* F10 */ + { 0x6e, -1, -1, -1 }, + { 0x6f, 0x106f, 0x106f, -1 }, /* F12 */ { 0x70, -1, -1, -1 }, - { 0x71, 0x800f, 0x1071, -1 }, /* F15 */ + { 0x71, 0x1071, 0x1071, -1 }, /* F15 */ { 0x72, 0x1072, 0x1072, -1 }, /* Help, insert */ { 0x73, 0x1073, 0x1073, -1 }, /* Home */ { 0x74, 0x1074, 0x1074, -1 }, /* Page up */ { 0x75, 0x1075, 0x1075, -1 }, /* keypad delete */ - { 0x76, 0x8004, 0x1076, -1 }, /* F4 */ + { 0x76, 0x1076, 0x1076, -1 }, /* F4 */ { 0x77, 0x1077, 0x1077, -1 }, /* keypad end */ - { 0x78, 0x8002, 0x1078, -1 }, /* F2 */ + { 0x78, 0x1078, 0x1078, -1 }, /* F2 */ { 0x79, 0x1079, 0x1079, -1 }, /* keypad page down */ - { 0x7a, 0x8001, 0x107a, -1 }, /* F1 */ - { 0x7b, 0x08, 0x08, -1 }, /* left */ /* remapped to 0x3b */ - { 0x7c, 0x15, 0x15, -1 }, /* right */ /* remapped to 0x3c */ - { 0x7d, 0x0a, 0x0a, -1 }, /* down */ /* remapped to 0x3d */ - { 0x7e, 0x0b, 0x0b, -1 }, /* up arrow */ /* remapped to 0x3e */ + { 0x7a, 0x107a, 0x107a, -1 }, /* F1 */ + { 0x7b, 0x0100, 0x0100, -1 }, /* right shift */ + { 0x7c, 0x4000, 0x4000, -1 }, /* right option */ + { 0x7d, 0x0200, 0x0200, -1 }, /* right control */ + { 0x7e, -1, -1, -1 }, { 0x7f, -1, -1, -1 }, /* Reset */ }; diff --git a/src/adb_keycodes.h b/src/adb_keycodes.h new file mode 100644 index 0000000..00dabd5 --- /dev/null +++ b/src/adb_keycodes.h @@ -0,0 +1,189 @@ +#ifndef adb_keycodes_h +#define adb_keycodes_h + +/* Taken from */ + +/* + * Summary: + * Virtual keycodes + * + * Discussion: + * These constants are the virtual keycodes defined originally in + * Inside Mac Volume V, pg. V-191. They identify physical keys on a + * keyboard. Those constants with "ANSI" in the name are labeled + * according to the key position on an ANSI-standard US keyboard. + * For example, kVK_ANSI_A indicates the virtual keycode for the key + * with the letter 'A' in the US keyboard layout. Other keyboard + * layouts may have the 'A' key label on a different physical key; + * in this case, pressing 'A' will generate a different virtual + * keycode. + */ +enum { + kVK_ANSI_A = 0x00, + kVK_ANSI_S = 0x01, + kVK_ANSI_D = 0x02, + kVK_ANSI_F = 0x03, + kVK_ANSI_H = 0x04, + kVK_ANSI_G = 0x05, + kVK_ANSI_Z = 0x06, + kVK_ANSI_X = 0x07, + kVK_ANSI_C = 0x08, + kVK_ANSI_V = 0x09, + kVK_ANSI_B = 0x0B, + kVK_ANSI_Q = 0x0C, + kVK_ANSI_W = 0x0D, + kVK_ANSI_E = 0x0E, + kVK_ANSI_R = 0x0F, + kVK_ANSI_Y = 0x10, + kVK_ANSI_T = 0x11, + kVK_ANSI_1 = 0x12, + kVK_ANSI_2 = 0x13, + kVK_ANSI_3 = 0x14, + kVK_ANSI_4 = 0x15, + kVK_ANSI_6 = 0x16, + kVK_ANSI_5 = 0x17, + kVK_ANSI_Equal = 0x18, + kVK_ANSI_9 = 0x19, + kVK_ANSI_7 = 0x1A, + kVK_ANSI_Minus = 0x1B, + kVK_ANSI_8 = 0x1C, + kVK_ANSI_0 = 0x1D, + kVK_ANSI_RightBracket = 0x1E, + kVK_ANSI_O = 0x1F, + kVK_ANSI_U = 0x20, + kVK_ANSI_LeftBracket = 0x21, + kVK_ANSI_I = 0x22, + kVK_ANSI_P = 0x23, + kVK_ANSI_L = 0x25, + kVK_ANSI_J = 0x26, + kVK_ANSI_Quote = 0x27, + kVK_ANSI_K = 0x28, + kVK_ANSI_Semicolon = 0x29, + kVK_ANSI_Backslash = 0x2A, + kVK_ANSI_Comma = 0x2B, + kVK_ANSI_Slash = 0x2C, + kVK_ANSI_N = 0x2D, + kVK_ANSI_M = 0x2E, + kVK_ANSI_Period = 0x2F, + kVK_ANSI_Grave = 0x32, + kVK_ANSI_KeypadDecimal = 0x41, + kVK_ANSI_KeypadMultiply = 0x43, + kVK_ANSI_KeypadPlus = 0x45, + kVK_ANSI_KeypadClear = 0x47, + kVK_ANSI_KeypadDivide = 0x4B, + kVK_ANSI_KeypadEnter = 0x4C, + kVK_ANSI_KeypadMinus = 0x4E, + kVK_ANSI_KeypadEquals = 0x51, + kVK_ANSI_Keypad0 = 0x52, + kVK_ANSI_Keypad1 = 0x53, + kVK_ANSI_Keypad2 = 0x54, + kVK_ANSI_Keypad3 = 0x55, + kVK_ANSI_Keypad4 = 0x56, + kVK_ANSI_Keypad5 = 0x57, + kVK_ANSI_Keypad6 = 0x58, + kVK_ANSI_Keypad7 = 0x59, + kVK_ANSI_Keypad8 = 0x5B, + kVK_ANSI_Keypad9 = 0x5C +}; + +/* keycodes for keys that are independent of keyboard layout*/ +enum { + kVK_Return = 0x24, + kVK_Tab = 0x30, + kVK_Space = 0x31, + kVK_Delete = 0x33, + kVK_Escape = 0x35, + kVK_Control = 0x36, + kVK_Command = 0x37, + kVK_Shift = 0x38, + kVK_CapsLock = 0x39, + kVK_Option = 0x3A, + kVK_LeftArrow = 0x3B, + kVK_RightArrow = 0x3C, + kVK_DownArrow = 0x3D, + kVK_UpArrow = 0x3E, + kVK_Function = 0x3F, + kVK_F17 = 0x40, + kVK_VolumeUp = 0x48, + kVK_VolumeDown = 0x49, + kVK_Mute = 0x4A, + kVK_F18 = 0x4F, + kVK_F19 = 0x50, + kVK_F20 = 0x5A, + kVK_F5 = 0x60, + kVK_F6 = 0x61, + kVK_F7 = 0x62, + kVK_F3 = 0x63, + kVK_F8 = 0x64, + kVK_F9 = 0x65, + kVK_F11 = 0x67, + kVK_F13 = 0x69, + kVK_F16 = 0x6A, + kVK_F14 = 0x6B, + kVK_F10 = 0x6D, + kVK_F12 = 0x6F, + kVK_F15 = 0x71, + kVK_Help = 0x72, + kVK_Home = 0x73, + kVK_PageUp = 0x74, + kVK_ForwardDelete = 0x75, + kVK_F4 = 0x76, + kVK_End = 0x77, + kVK_F2 = 0x78, + kVK_PageDown = 0x79, + kVK_F1 = 0x7A, + + + + kVK_Reset = 0x7F, /* actually 7F7F */ + + kVK_Insert = kVK_Help, + +#if 0 + kVK_RightCommand = 0x37, + kVK_RightShift = 0x7B, + kVK_RightOption = 0x7C, + kVK_RightControl = 0x7D, +#else + kVK_RightCommand = kVK_Command, + kVK_RightShift = kVK_Shift, + kVK_RightOption = kVK_Option, + kVK_RightControl = kVK_Control, +#endif + +#if 0 +/* Mac OS used a KMAP resource to remap ADB codes: + * Control 36 -> 3B + * Left Arrow 3B -> 7B + * Right Arrow 3C -> 7C + * Down Arrow 3D -> 7D + * Up Arrow 3E -> 7E + * Right Shift 7B* -> 3C + * Right Option 7C* -> 3D + * Right Control 7D* -> 3E + * + * Right shift/option/control only generate unique codes + * when device handler ID in keyboard register 3 has a + * value of $3 (as opposed to $2). + * + * See Guide to the Macintosh Family Hardware, ch 8, page 306-310 + * + * KMAP also maps $7e to $36 ... ? + * + */ + + kVK_RightCommand = 0x36, + kVK_RightShift = 0x3C, + kVK_RightOption = 0x3D, + kVK_RightControl = 0x3E, + + kVK_LeftArrow = 0x7B, + kVK_RightArrow = 0x7C, + kVK_DownArrow = 0x7D, + kVK_UpArrow = 0x7E, + +#endif + +}; + +#endif diff --git a/src/sdl2_driver.c b/src/sdl2_driver.c index c5697a9..e56f6f0 100644 --- a/src/sdl2_driver.c +++ b/src/sdl2_driver.c @@ -31,6 +31,8 @@ unsigned int lastTime = 0, currentTime, frames; #define ControlMask 4 #define LockMask 2 +#include "adb_keycodes.h" + int g_use_shmem = 0; int g_num_check_input_calls = 0; @@ -95,112 +97,128 @@ void handle_sdl_mouse_event(SDL_Event event); int g_num_a2_keycodes = 0; int a2_key_to_sdlkeycode[][3] = { - { 0x35, SDLK_ESCAPE, 0 }, - { 0x7a, SDLK_F1, 0 }, - { 0x78, SDLK_F2, 0 }, - { 0x63, SDLK_F3, 0 }, - { 0x76, SDLK_F4, 0 }, - { 0x60, SDLK_F5, 0 }, - { 0x61, SDLK_F6, 0 }, - { 0x62, SDLK_F7, 0 }, - { 0x64, SDLK_F8, 0 }, - { 0x65, SDLK_F9, 0 }, - { 0x6d, SDLK_F10, 0 }, - { 0x67, SDLK_F11, 0 }, - { 0x6f, SDLK_F12, 0 }, - { 0x69, SDLK_F13, 0 }, - { 0x6b, SDLK_F14, 0 }, - { 0x71, SDLK_F15, 0 }, - { 0x7f, SDLK_PAUSE, 0 }, - { 0x32, SDLK_BACKQUOTE, '~' }, /* Key number 18? */ - { 0x12, SDLK_1, '!' }, - { 0x13, SDLK_2, '@' }, - { 0x14, SDLK_3, '#' }, - { 0x15, SDLK_4, '$' }, - { 0x17, SDLK_5, '%' }, - { 0x16, SDLK_6, '^' }, - { 0x1a, SDLK_7, '&' }, - { 0x1c, SDLK_8, '*' }, - { 0x19, SDLK_9, '(' }, - { 0x1d, SDLK_0, ')' }, - { 0x1b, SDLK_MINUS, SDLK_UNDERSCORE }, - { 0x18, SDLK_EQUALS, SDLK_PLUS }, - { 0x33, SDLK_BACKSPACE, 0 }, - { 0x72, SDLK_INSERT, 0 }, /* Help? XK_Help */ - /* { 0x73, XK_Home, 0 }, alias XK_Home to be XK_KP_Equal! */ - { 0x74, SDLK_PAGEUP, 0 }, - { 0x47, SDLK_NUMLOCKCLEAR, 0 }, /* Clear, XK_Clear */ - { 0x51, SDLK_KP_EQUALS, 0 }, /* Note XK_Home alias! XK_Home */ - { 0x4b, SDLK_KP_DIVIDE, 0 }, - { 0x43, SDLK_KP_MULTIPLY, 0 }, - { 0x30, SDLK_TAB, 0 }, - { 0x0c, SDLK_q, 'Q' }, - { 0x0d, SDLK_w, 'W' }, - { 0x0e, SDLK_e, 'E' }, - { 0x0f, SDLK_r, 'R' }, - { 0x11, SDLK_t, 'T' }, - { 0x10, SDLK_y, 'Y' }, - { 0x20, SDLK_u, 'U' }, - { 0x22, SDLK_i, 'I' }, - { 0x1f, SDLK_o, 'O' }, - { 0x23, SDLK_p, 'P' }, - { 0x21, SDLK_RIGHTBRACKET, '{' }, - { 0x1e, SDLK_LEFTBRACKET, '}' }, - { 0x2a, SDLK_BACKSLASH, '|' }, /* backslash, bar */ - { 0x75, SDLK_DELETE, 0 }, - { 0x77, SDLK_END, 0 }, - { 0x79, SDLK_PAGEDOWN, 0 }, - { 0x59, SDLK_KP_7, SDLK_HOME }, - { 0x5b, SDLK_KP_8, SDLK_UP }, - { 0x5c, SDLK_KP_9, SDLK_PAGEUP }, - { 0x4e, SDLK_KP_MINUS, 0 }, - { 0x39, SDLK_CAPSLOCK, 0 }, - { 0x00, SDLK_a, 'A' }, - { 0x01, SDLK_s, 'S' }, - { 0x02, SDLK_d, 'D' }, - { 0x03, SDLK_f, 'F' }, - { 0x05, SDLK_g, 'G' }, - { 0x04, SDLK_h, 'H' }, - { 0x26, SDLK_j, 'J' }, - { 0x28, SDLK_k, 'K' }, - { 0x25, SDLK_l, 'L' }, - { 0x29, SDLK_SEMICOLON, SDLK_COLON }, - { 0x27, SDLK_QUOTE, SDLK_QUOTEDBL }, - { 0x24, SDLK_RETURN, 0 }, - { 0x56, SDLK_KP_4, SDLK_LEFT}, - { 0x57, SDLK_KP_5, 0 }, - { 0x58, SDLK_KP_6, SDLK_RIGHT }, - { 0x45, SDLK_KP_PLUS, 0 }, - { 0x38, SDLK_LSHIFT, SDLK_RSHIFT }, - { 0x06, SDLK_z, 'Z' }, - { 0x07, SDLK_x, 'X' }, - { 0x08, SDLK_c, 'C' }, - { 0x09, SDLK_v, 'V' }, - { 0x0b, SDLK_b, 'B' }, - { 0x2d, SDLK_n, 'N' }, - { 0x2e, SDLK_m, 'M' }, - { 0x2b, SDLK_COMMA, SDLK_LESS }, - { 0x2f, SDLK_PERIOD, SDLK_GREATER }, - { 0x2c, SDLK_SLASH, SDLK_QUESTION }, - { 0x3e, SDLK_UP, 0 }, - { 0x53, SDLK_KP_1, 0 }, - { 0x54, SDLK_KP_2, SDLK_DOWN }, - { 0x55, SDLK_KP_3, SDLK_PAGEDOWN }, - { 0x36, SDLK_RCTRL, SDLK_LCTRL }, + { kVK_Escape, SDLK_ESCAPE, 0 }, + { kVK_F1, SDLK_F1, 0 }, + { kVK_F2, SDLK_F2, 0 }, + { kVK_F3, SDLK_F3, 0 }, + { kVK_F4, SDLK_F4, 0 }, + { kVK_F5, SDLK_F5, 0 }, + { kVK_F6, SDLK_F6, 0 }, + { kVK_F7, SDLK_F7, 0 }, + { kVK_F8, SDLK_F8, 0 }, + { kVK_F9, SDLK_F9, 0 }, + { kVK_F10, SDLK_F10, 0 }, + { kVK_F11, SDLK_F11, 0 }, + { kVK_F12, SDLK_F12, 0 }, + { kVK_F13, SDLK_F13, 0 }, + { kVK_F14, SDLK_F14, 0 }, + { kVK_F15, SDLK_F15, 0 }, + { kVK_F16, SDLK_F16, 0 }, + { kVK_F17, SDLK_F17, 0 }, + { kVK_F18, SDLK_F18, 0 }, + { kVK_F19, SDLK_F19, 0 }, + { kVK_F20, SDLK_F20, 0 }, + { kVK_Reset, SDLK_PAUSE, 0 }, + { kVK_ANSI_Grave, SDLK_BACKQUOTE, '~' }, + { kVK_ANSI_1, SDLK_1, '!' }, + { kVK_ANSI_2, SDLK_2, '@' }, + { kVK_ANSI_3, SDLK_3, '#' }, + { kVK_ANSI_4, SDLK_4, '$' }, + { kVK_ANSI_5, SDLK_5, '%' }, + { kVK_ANSI_6, SDLK_6, '^' }, + { kVK_ANSI_7, SDLK_7, '&' }, + { kVK_ANSI_8, SDLK_8, '*' }, + { kVK_ANSI_9, SDLK_9, '(' }, + { kVK_ANSI_0, SDLK_0, ')' }, + { kVK_ANSI_Minus, SDLK_MINUS, SDLK_UNDERSCORE }, + { kVK_ANSI_Equal, SDLK_EQUALS, SDLK_PLUS }, + { kVK_Delete, SDLK_BACKSPACE, 0 }, + { kVK_Help, SDLK_INSERT, 0 }, /* Help? XK_Help */ + { kVK_Home, SDLK_HOME, 0 }, + { kVK_PageUp, SDLK_PAGEUP, 0 }, + { kVK_Tab, SDLK_TAB, 0 }, + { kVK_ANSI_Q, SDLK_q, 'Q' }, + { kVK_ANSI_W, SDLK_w, 'W' }, + { kVK_ANSI_E, SDLK_e, 'E' }, + { kVK_ANSI_R, SDLK_r, 'R' }, + { kVK_ANSI_T, SDLK_t, 'T' }, + { kVK_ANSI_Y, SDLK_y, 'Y' }, + { kVK_ANSI_U, SDLK_u, 'U' }, + { kVK_ANSI_I, SDLK_i, 'I' }, + { kVK_ANSI_O, SDLK_o, 'O' }, + { kVK_ANSI_P, SDLK_p, 'P' }, + { kVK_ANSI_LeftBracket, SDLK_LEFTBRACKET, '{' }, + { kVK_ANSI_RightBracket, SDLK_RIGHTBRACKET, '}' }, + { kVK_ANSI_Backslash, SDLK_BACKSLASH, '|' }, /* backslash, bar */ + { kVK_ForwardDelete, SDLK_DELETE, 0 }, + { kVK_End, SDLK_END, 0 }, + { kVK_PageDown, SDLK_PAGEDOWN, 0 }, + { kVK_ANSI_A, SDLK_a, 'A' }, + { kVK_ANSI_S, SDLK_s, 'S' }, + { kVK_ANSI_D, SDLK_d, 'D' }, + { kVK_ANSI_F, SDLK_f, 'F' }, + { kVK_ANSI_G, SDLK_g, 'G' }, + { kVK_ANSI_H, SDLK_h, 'H' }, + { kVK_ANSI_J, SDLK_j, 'J' }, + { kVK_ANSI_K, SDLK_k, 'K' }, + { kVK_ANSI_L, SDLK_l, 'L' }, + { kVK_ANSI_Semicolon, SDLK_SEMICOLON, SDLK_COLON }, + { kVK_ANSI_Quote, SDLK_QUOTE, SDLK_QUOTEDBL }, + { kVK_Return, SDLK_RETURN, 0 }, + { kVK_Shift, SDLK_LSHIFT, 0 }, + { kVK_RightShift, SDLK_RSHIFT, 0 }, + { kVK_ANSI_Z, SDLK_z, 'Z' }, + { kVK_ANSI_X, SDLK_x, 'X' }, + { kVK_ANSI_C, SDLK_c, 'C' }, + { kVK_ANSI_V, SDLK_v, 'V' }, + { kVK_ANSI_B, SDLK_b, 'B' }, + { kVK_ANSI_N, SDLK_n, 'N' }, + { kVK_ANSI_M, SDLK_m, 'M' }, + { kVK_ANSI_Comma, SDLK_COMMA, SDLK_LESS }, + { kVK_ANSI_Period, SDLK_PERIOD, SDLK_GREATER }, + { kVK_ANSI_Slash, SDLK_SLASH, SDLK_QUESTION }, + + { kVK_CapsLock, SDLK_CAPSLOCK, 0 }, + + { kVK_Control, SDLK_LCTRL, 0 }, + { kVK_RightControl, SDLK_RCTRL, 0 }, #if defined(__APPLE__) - { 0x3a, SDLK_LALT, SDLK_RALT }, /* Option */ - { 0x37, SDLK_LGUI, SDLK_RGUI }, /* Command */ + { kVK_Option, SDLK_LALT, 0 }, /* Option */ + { kVK_RightOption, SDLK_RALT, 0 }, /* Option */ + { kVK_Command, SDLK_LGUI, 0 }, /* Command */ + { kVK_RightCommand, SDLK_RGUI, 0 }, /* Command */ #else - { 0x3a, SDLK_LGUI, SDLK_RGUI }, /* Command */ - { 0x37, SDLK_LALT, SDLK_RALT }, /* Option */ + { kVK_Option, SDLK_LGUI, 0 }, /* Command */ + { kVK_RightOption, SDLK_RGUI, 0 }, /* Command */ + { kVK_Command, SDLK_LALT, 0 }, /* Option */ + { kVK_RightCommand, SDLK_RALT, 0 }, /* Option */ #endif - { 0x31, SDLK_SPACE, 0 }, - { 0x3b, SDLK_LEFT, 0 }, - { 0x3d, SDLK_DOWN, 0 }, - { 0x3c, SDLK_RIGHT, 0 }, - { 0x52, SDLK_KP_0, 0 }, - { 0x41, SDLK_KP_PERIOD, 0 }, - { 0x4c, SDLK_KP_ENTER, 0 }, + { kVK_Space, SDLK_SPACE, 0 }, + { kVK_LeftArrow, SDLK_LEFT, 0 }, + { kVK_DownArrow, SDLK_DOWN, 0 }, + { kVK_RightArrow, SDLK_RIGHT, 0 }, + { kVK_UpArrow, SDLK_UP, 0 }, + + { kVK_ANSI_Keypad0, SDLK_KP_0, 0 }, + { kVK_ANSI_Keypad1, SDLK_KP_1, 0 }, + { kVK_ANSI_Keypad2, SDLK_KP_2, 0 }, + { kVK_ANSI_Keypad3, SDLK_KP_3, 0 }, + { kVK_ANSI_Keypad4, SDLK_KP_4, 0 }, + { kVK_ANSI_Keypad5, SDLK_KP_5, 0 }, + { kVK_ANSI_Keypad6, SDLK_KP_6, 0 }, + { kVK_ANSI_Keypad7, SDLK_KP_7, 0 }, + { kVK_ANSI_Keypad8, SDLK_KP_8, 0 }, + { kVK_ANSI_Keypad9, SDLK_KP_9, 0 }, + + { kVK_ANSI_KeypadMinus, SDLK_KP_MINUS, 0 }, + { kVK_ANSI_KeypadPlus, SDLK_KP_PLUS, 0 }, + { kVK_ANSI_KeypadEquals, SDLK_KP_EQUALS, 0 }, /* Note XK_Home alias! XK_Home */ + { kVK_ANSI_KeypadDivide, SDLK_KP_DIVIDE, 0 }, + { kVK_ANSI_KeypadMultiply,SDLK_KP_MULTIPLY, 0 }, + { kVK_ANSI_KeypadDecimal, SDLK_KP_PERIOD, 0 }, + { kVK_ANSI_KeypadEnter, SDLK_KP_ENTER, 0 }, + { kVK_ANSI_KeypadClear, SDLK_NUMLOCKCLEAR, 0 }, /* Clear, XK_Clear */ + { -1, -1, -1 } }; From b6406159bd7b35e05a68c7d42aad42f856f11c0a Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 17 Feb 2019 18:46:19 -0500 Subject: [PATCH 3/9] unix host mli bug fixes 1. file/directory storage types were reversed 2. month was off-by-one. --- src/unix_host_common.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/unix_host_common.c b/src/unix_host_common.c index 0df5b91..c5075d9 100644 --- a/src/unix_host_common.c +++ b/src/unix_host_common.c @@ -126,7 +126,7 @@ void host_set_date_time(word32 ptr, time_t time) { word16 tmp = 0; tmp |= (tm->tm_year % 100) << 9; - tmp |= tm->tm_mon << 5; + tmp |= (tm->tm_mon + 1) << 5; tmp |= tm->tm_mday; set_memory16_c(ptr, tmp, 0); @@ -146,7 +146,7 @@ word32 host_convert_date_time(time_t time) { word16 dd = 0; dd |= (tm->tm_year % 100) << 9; - dd |= tm->tm_mon << 5; + dd |= (tm->tm_mon + 1) << 5; dd |= tm->tm_mday; word16 tt = 0; @@ -503,10 +503,10 @@ unsigned host_storage_type(const char *path, word16 *error) { *error = host_map_errno_path(errno, path); return 0; } - if (S_ISREG(st.st_mode)) { + if (S_ISDIR(st.st_mode)) { return host_is_root(&st) ? 0x0f : directoryFile; } - if (S_ISDIR(st.st_mode)) return standardFile; + if (S_ISREG(st.st_mode)) return standardFile; *error = badStoreType; return 0; } From e9e9fcfd59c21508bc1144b7ed35824e41c6eef1 Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 17 Feb 2019 21:18:11 -0500 Subject: [PATCH 4/9] host mli - opening/closing a directory would close fd 0 (aka stdin). --- src/host_mli.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/host_mli.c b/src/host_mli.c index 5356e94..48bec74 100644 --- a/src/host_mli.c +++ b/src/host_mli.c @@ -1048,6 +1048,11 @@ static int mli_open(unsigned dcb, const char *name, const char *path) { word16 terr = host_get_file_info(path, &fi); if (terr) return terr; +#if _WIN32 + file->h = INVALID_HANDLE_VALUE; +#else + file->fd = -1; +#endif if (fi.storage_type == 0x0f || fi.storage_type == 0x0d) { unsigned blocks; From 22e488df3022db3b79e8b399c7596d255a6fe229 Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Mon, 18 Feb 2019 12:38:15 -0500 Subject: [PATCH 5/9] GCC's documentation states that __LP64__ is defined if sizeof(void *) == 8 and sizeof(int) == 4. Well, under mingw64 that doesn't seem to be true. And it causes lots of warnings. Anyhow, as of c99, stdint.h defines a type specifically for casting pointers to integers. It also defines fixed size types so no need to guess or sniff compilers. --- src/defc.h | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/src/defc.h b/src/defc.h index d6317d7..51cff56 100644 --- a/src/defc.h +++ b/src/defc.h @@ -6,6 +6,7 @@ */ #include "defcomm.h" +#include // OG redirect printf to console #ifdef ACTIVEGS @@ -18,14 +19,11 @@ extern "C" int fOutputInfo(FILE*,const char* format,...); #define STRUCT(a) typedef struct _ ## a a; struct _ ## a -typedef unsigned char byte; -typedef unsigned short word16; -typedef unsigned int word32; -#if _MSC_VER -typedef unsigned __int64 word64; -#else -typedef unsigned long long word64; -#endif +typedef uint8_t byte; +typedef uint16_t word16; +typedef uint32_t word32; +typedef uint64_t word64; +#define PTR2WORD(a) ((uintptr_t)(a)) void U_STACK_TRACE(); @@ -228,11 +226,6 @@ STRUCT(Emustate_word32list) { word32 *wptr; }; -#ifdef __LP64__ -# define PTR2WORD(a) ((unsigned long)(a)) -#else -# define PTR2WORD(a) ((unsigned int)(a)) -#endif #define ALTZP (g_c068_statereg & 0x80) From 3f8cce8286dc98ea1735c689fc8fb509cd475a4b Mon Sep 17 00:00:00 2001 From: Dagen Brock Date: Thu, 28 Mar 2019 12:45:27 -0500 Subject: [PATCH 6/9] add definition --- src/protos_windriver.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/protos_windriver.h b/src/protos_windriver.h index d6f42fe..3fad877 100644 --- a/src/protos_windriver.h +++ b/src/protos_windriver.h @@ -16,6 +16,7 @@ void win_event_key(HWND hwnd, UINT raw_vk, BOOL down, int repeat, UINT flags); void win_event_quit(HWND hwnd); void win_event_redraw(void); LRESULT CALLBACK win_event_handler(HWND hwnd, UINT umsg, WPARAM wParam, LPARAM lParam); +LRESULT CALLBACK win_ll_keyboard(int nCode, WPARAM wParam, LPARAM lParam); void inspect_file(LPTSTR lpstrFile); int main(int argc, char **argv); void check_input_events(void); From 1433791eaa4508eed5e8643780cc0fc7ba61033c Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sat, 6 Apr 2019 23:04:24 -0400 Subject: [PATCH 7/9] fflush stderr since MSVCRT's stdio doesn't support line-oriented buffering, as it should. --- src/sim65816.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/sim65816.c b/src/sim65816.c index 5ef8f0e..56e2a2e 100644 --- a/src/sim65816.c +++ b/src/sim65816.c @@ -1486,6 +1486,7 @@ void run_prog() { int fast, zip_speed, faster_than_28, unl_speed; int this_type; + fflush(stderr); fflush(stdout); g_cur_sim_dtime = 0.0; @@ -1508,6 +1509,7 @@ void run_prog() { } while(1) { + fflush(stderr); fflush(stdout); // OG Disabling control panel From 865b3d901b54308bf5d6d07fa8e2ad0fa7334289 Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 7 Apr 2019 01:14:35 -0400 Subject: [PATCH 8/9] host fst fix reported in c.e.a2 - when dropping into p8, fst_shutdown is called. when returning to gs/os, fst_startup is NOT called. This effective unmounts the host file system, permanently, since it assumed fst_startup would get called again. fst_shutdown code now closes any open files but does not otherwise unmount. --- src/host_fst.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/host_fst.c b/src/host_fst.c index 425a7c1..40043e9 100644 --- a/src/host_fst.c +++ b/src/host_fst.c @@ -407,6 +407,10 @@ static char *get_path2(void) { } +/* + * shutdown is called when switching to p8. + * startup is ONLY called during initial boot. + */ static word32 fst_shutdown(void) { @@ -418,7 +422,7 @@ static word32 fst_shutdown(void) { free_fd(head); head = next; } - host_shutdown(); + //host_shutdown(); return 0; } @@ -426,6 +430,8 @@ static word32 fst_startup(void) { // if restart, close any previous files. fst_shutdown(); + host_shutdown(); + memset(&cookies, 0, sizeof(cookies)); return host_startup(); From 091b0208762a47c5496ca6763931ff718bb3620a Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 7 Apr 2019 11:21:54 -0400 Subject: [PATCH 9/9] clean up windows key mapping to use adb names codes. also fixes a few mistakes with keypad values. --- src/win_keymap.h | 228 ++++++++++++++++++++++++----------------------- 1 file changed, 116 insertions(+), 112 deletions(-) diff --git a/src/win_keymap.h b/src/win_keymap.h index 202c9c4..accf987 100644 --- a/src/win_keymap.h +++ b/src/win_keymap.h @@ -1,133 +1,137 @@ /* this table is used to search for the Windows VK_* in col 1 or 2 */ /* flags bit 8 is or'ed into the VK, so we can distinguish keypad keys */ /* regardless of numlock */ + int g_a2_key_to_wsym[][3] = { - { 0x35, VK_ESCAPE, 0 }, - { 0x7a, VK_F1, 0 }, - { 0x78, VK_F2, 0 }, - { 0x63, VK_F3, 0 }, - { 0x76, VK_F4, 0 }, - { 0x60, VK_F5, 0 }, - { 0x61, VK_F6, 0 }, - { 0x62, VK_F7, 0 }, - { 0x64, VK_F8, 0 }, - { 0x65, VK_F9, 0 }, - { 0x6d, VK_F10, 0 }, - { 0x67, VK_F11, 0 }, - { 0x6f, VK_F12, 0 }, - { 0x69, VK_F13, 0 }, - { 0x6b, VK_F14, 0 }, - { 0x71, VK_F15, 0 }, + { kVK_Escape, VK_ESCAPE, 0 }, + { kVK_F1, VK_F1, 0 }, + { kVK_F2, VK_F2, 0 }, + { kVK_F3, VK_F3, 0 }, + { kVK_F4, VK_F4, 0 }, + { kVK_F5, VK_F5, 0 }, + { kVK_F6, VK_F6, 0 }, + { kVK_F7, VK_F7, 0 }, + { kVK_F8, VK_F8, 0 }, + { kVK_F9, VK_F9, 0 }, + { kVK_F10, VK_F10, 0 }, + { kVK_F11, VK_F11, 0 }, + { kVK_F12, VK_F12, 0 }, + { kVK_F13, VK_F13, 0 }, + { kVK_F14, VK_F14, 0 }, + { kVK_F15, VK_F15, 0 }, + { kVK_Reset, VK_PAUSE, VK_PAUSE+0x100 }, + { kVK_Reset, VK_CANCEL, VK_CANCEL+0x100 }, - { 0x7f, VK_PAUSE, VK_PAUSE+0x100 }, - { 0x7f, VK_CANCEL, VK_CANCEL+0x100 }, + { kVK_ANSI_Grave, VK_OEM_3, 0 }, /* '`' */ + { kVK_ANSI_1, '1', 0 }, + { kVK_ANSI_2, '2', 0 }, + { kVK_ANSI_3, '3', 0 }, + { kVK_ANSI_4, '4', 0 }, + { kVK_ANSI_5, '5', 0 }, + { kVK_ANSI_6, '6', 0 }, + { kVK_ANSI_7, '7', 0 }, + { kVK_ANSI_8, '8', 0 }, + { kVK_ANSI_9, '9', 0 }, + { kVK_ANSI_0, '0', 0 }, + { kVK_ANSI_Minus, VK_OEM_MINUS, 0 }, /* '-' */ + { kVK_ANSI_Equal, VK_OEM_PLUS, 0 }, /* '=' */ + { kVK_Delete, VK_BACK, 0 }, /* backspace */ + { kVK_Insert, VK_INSERT+0x100, 0 }, /* Insert key */ + { kVK_PageUp, VK_PRIOR+0x100, 0 }, /* pageup */ + { kVK_Home, VK_HOME+0x100, 0 }, /* KP_equal is HOME key */ - { 0x32, 0xc0, 0 }, /* '`' */ - { 0x12, '1', 0 }, - { 0x13, '2', 0 }, - { 0x14, '3', 0 }, - { 0x15, '4', 0 }, - { 0x17, '5', 0 }, - { 0x16, '6', 0 }, - { 0x1a, '7', 0 }, - { 0x1c, '8', 0 }, - { 0x19, '9', 0 }, - { 0x1d, '0', 0 }, - { 0x1b, 0xbd, 0 }, /* '-' */ - { 0x18, 0xbb, 0 }, /* '=' */ - { 0x33, VK_BACK, 0 }, /* backspace */ - { 0x72, VK_INSERT+0x100, 0 }, /* Insert key */ - { 0x74, VK_PRIOR+0x100, 0 }, /* pageup */ - { 0x47, VK_NUMLOCK, VK_NUMLOCK+0x100 }, /* clear */ - { 0x51, VK_HOME+0x100, 0 }, - { 0x4b, VK_DIVIDE, VK_DIVIDE+0x100 }, - { 0x43, VK_MULTIPLY, VK_MULTIPLY+0x100 }, + { kVK_Tab, VK_TAB, 0 }, + { kVK_ANSI_Q, 'Q', 0 }, + { kVK_ANSI_W, 'W', 0 }, + { kVK_ANSI_E, 'E', 0 }, + { kVK_ANSI_R, 'R', 0 }, + { kVK_ANSI_T, 'T', 0 }, + { kVK_ANSI_Y, 'Y', 0 }, + { kVK_ANSI_U, 'U', 0 }, + { kVK_ANSI_I, 'I', 0 }, + { kVK_ANSI_O, 'O', 0 }, + { kVK_ANSI_P, 'P', 0 }, + { kVK_ANSI_LeftBracket, VK_OEM_4, 0 }, /* [ */ + { kVK_ANSI_RightBracket, VK_OEM_6, 0 }, /* ] */ + { kVK_ANSI_Backslash, VK_OEM_5, 0 }, /* backslash, bar */ + { kVK_ForwardDelete, VK_DELETE+0x100, 0 }, + { kVK_End, VK_END+0x100, 0 }, + { kVK_PageDown, VK_NEXT+0x100, 0 }, - { 0x30, VK_TAB, 0 }, - { 0x0c, 'Q', 0 }, - { 0x0d, 'W', 0 }, - { 0x0e, 'E', 0 }, - { 0x0f, 'R', 0 }, - { 0x11, 'T', 0 }, - { 0x10, 'Y', 0 }, - { 0x20, 'U', 0 }, - { 0x22, 'I', 0 }, - { 0x1f, 'O', 0 }, - { 0x23, 'P', 0 }, - { 0x21, 0xdb, 0 }, /* [ */ - { 0x1e, 0xdd, 0 }, /* ] */ - { 0x2a, 0xdc, 0 }, /* backslash, bar */ - { 0x75, VK_DELETE+0x100, 0 }, - { 0x77, VK_END+0x100, VK_END }, - { 0x79, VK_NEXT+0x100, 0 }, - { 0x59, VK_NUMPAD7, VK_HOME }, - { 0x5b, VK_NUMPAD8, VK_UP }, - { 0x5c, VK_NUMPAD9, VK_PRIOR }, - { 0x4e, VK_SUBTRACT, VK_SUBTRACT+0x100 }, + // { kVK_CapsLock, VK_CAPITAL, 0 }, // Handled specially! + { kVK_ANSI_A, 'A', 0 }, + { kVK_ANSI_S, 'S', 0 }, + { kVK_ANSI_D, 'D', 0 }, + { kVK_ANSI_F, 'F', 0 }, + { kVK_ANSI_G, 'G', 0 }, + { kVK_ANSI_H, 'H', 0 }, + { kVK_ANSI_J, 'J', 0 }, + { kVK_ANSI_K, 'K', 0 }, + { kVK_ANSI_L, 'L', 0 }, + { kVK_ANSI_Semicolon, VK_OEM_1, 0 }, /* ; */ + { kVK_ANSI_Quote, VK_OEM_7, 0 }, /* single quote */ + { kVK_Return, VK_RETURN, 0 }, - // { 0x39, VK_CAPITAL, 0 }, // Handled specially! - { 0x00, 'A', 0 }, - { 0x01, 'S', 0 }, - { 0x02, 'D', 0 }, - { 0x03, 'F', 0 }, - { 0x05, 'G', 0 }, - { 0x04, 'H', 0 }, - { 0x26, 'J', 0 }, - { 0x28, 'K', 0 }, - { 0x25, 'L', 0 }, - { 0x29, 0xba, 0 }, /* ; */ - { 0x27, 0xde, 0 }, /* single quote */ - { 0x24, VK_RETURN, 0 }, - { 0x56, VK_NUMPAD4, VK_LEFT }, - { 0x57, VK_NUMPAD5, VK_CLEAR }, - { 0x58, VK_NUMPAD6, VK_RIGHT }, - { 0x45, VK_ADD, 0 }, + { kVK_Shift, VK_SHIFT, 0 }, + { kVK_Shift, VK_LSHIFT, 0 }, + { kVK_Shift, VK_RSHIFT, 0 }, + { kVK_ANSI_Z, 'Z', 0 }, + { kVK_ANSI_X, 'X', 0 }, + { kVK_ANSI_C, 'C', 0 }, + { kVK_ANSI_V, 'V', 0 }, + { kVK_ANSI_B, 'B', 0 }, + { kVK_ANSI_N, 'N', 0 }, + { kVK_ANSI_M, 'M', 0 }, + { kVK_ANSI_Comma, VK_OEM_COMMA, 0 }, /* , */ + { kVK_ANSI_Period, VK_OEM_PERIOD, 0 }, /* . */ + { kVK_ANSI_Slash, VK_OEM_2, 0 }, /* / */ - { 0x38, VK_SHIFT, 0 }, - { 0x38, VK_LSHIFT, 0 }, - { 0x38, VK_RSHIFT, 0 }, - { 0x06, 'Z', 0 }, - { 0x07, 'X', 0 }, - { 0x08, 'C', 0 }, - { 0x09, 'V', 0 }, - { 0x0b, 'B', 0 }, - { 0x2d, 'N', 0 }, - { 0x2e, 'M', 0 }, - { 0x2b, 0xbc, 0 }, /* , */ - { 0x2f, 0xbe, 0 }, /* . */ - { 0x2c, 0xbf, 0 }, /* / */ - { 0x3e, VK_UP+0x100, 0 }, - { 0x53, VK_NUMPAD1, VK_END }, - { 0x54, VK_NUMPAD2, VK_DOWN }, - { 0x55, VK_NUMPAD3, VK_NEXT }, - - { 0x36, VK_CONTROL, VK_CONTROL+0x100 }, - { 0x36, VK_LCONTROL, VK_LCONTROL+0x100 }, - { 0x36, VK_RCONTROL, VK_RCONTROL+0x100 }, - { 0x3a, VK_SNAPSHOT+0x100, 0 },/* Opt=prntscrn or alt-r */ /* LMENU/RMENU = alt key = command*/ /* LWIN / RWIN = windows key = option */ /* weird menu key = APPS = option */ - { 0x3A, VK_LWIN, VK_LWIN+0x100 }, - { 0x3A, VK_RWIN, VK_RWIN+0x100 }, - { 0x3A, VK_APPS, VK_APPS+0x100 }, - { 0x37, VK_MENU, VK_MENU+0x100 }, - { 0x37, VK_LMENU, VK_LMENU+0x100 }, - { 0x37, VK_RMENU, VK_RMENU+0x100 }, + { kVK_Control, VK_CONTROL, VK_CONTROL+0x100 }, + { kVK_Control, VK_LCONTROL, VK_LCONTROL+0x100 }, + { kVK_Control, VK_RCONTROL, VK_RCONTROL+0x100 }, + { kVK_Option, VK_SNAPSHOT+0x100, 0 },/* Opt=prntscrn or alt-r */ + { kVK_Option, VK_LWIN, VK_LWIN+0x100 }, + { kVK_Option, VK_RWIN, VK_RWIN+0x100 }, + { kVK_Option, VK_APPS, VK_APPS+0x100 }, + + { kVK_Command, VK_MENU, VK_MENU+0x100 }, + { kVK_Command, VK_LMENU, VK_LMENU+0x100 }, + { kVK_Command, VK_RMENU, VK_RMENU+0x100 }, #ifdef ACTIVEGS - { 0x7F, VK_SCROLL,0 }, /* RESET */ + { kVK_Reset, VK_SCROLL,0 }, /* RESET */ #endif - { 0x31, ' ', 0 }, - { 0x3b, VK_LEFT+0x100, 0 }, - { 0x3d, VK_DOWN+0x100, 0 }, - { 0x3c, VK_RIGHT+0x100, 0 }, - { 0x52, VK_NUMPAD0, VK_INSERT }, - { 0x41, VK_DECIMAL, VK_DELETE }, - { 0x4c, VK_RETURN+0x100, 0 }, + { kVK_Space, ' ', 0 }, + { kVK_LeftArrow, VK_LEFT+0x100, 0 }, + { kVK_DownArrow, VK_DOWN+0x100, 0 }, + { kVK_RightArrow, VK_RIGHT+0x100, 0 }, + { kVK_UpArrow, VK_UP+0x100, 0 }, + + + { kVK_ANSI_Keypad1, VK_NUMPAD1, VK_END }, + { kVK_ANSI_Keypad2, VK_NUMPAD2, VK_DOWN }, + { kVK_ANSI_Keypad3, VK_NUMPAD3, VK_NEXT }, + { kVK_ANSI_Keypad4, VK_NUMPAD4, VK_LEFT }, + { kVK_ANSI_Keypad5, VK_NUMPAD5, VK_CLEAR }, + { kVK_ANSI_Keypad6, VK_NUMPAD6, VK_RIGHT }, + { kVK_ANSI_Keypad7, VK_NUMPAD7, VK_HOME }, + { kVK_ANSI_Keypad8, VK_NUMPAD8, VK_UP }, + { kVK_ANSI_Keypad9, VK_NUMPAD9, VK_PRIOR }, + { kVK_ANSI_Keypad0, VK_NUMPAD0, VK_INSERT }, + { kVK_ANSI_KeypadDecimal, VK_DECIMAL, VK_DECIMAL }, + { kVK_ANSI_KeypadEnter, VK_RETURN+0x100, 0 }, + { kVK_ANSI_KeypadClear, VK_NUMLOCK, VK_NUMLOCK+0x100 }, /* clear */ + { kVK_ANSI_KeypadMinus, VK_SUBTRACT, VK_SUBTRACT+0x100 }, + { kVK_ANSI_KeypadPlus, VK_ADD, VK_ADD+0x100 }, + { kVK_ANSI_KeypadDivide, VK_DIVIDE, VK_DIVIDE+0x100 }, + { kVK_ANSI_KeypadMultiply, VK_MULTIPLY, VK_MULTIPLY+0x100 }, + { -1, -1, -1 } };