in_vk.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277
  1. #define RC_INVOKED // we only need defines
  2. #include <winuser.h>
  3. #undef RC_INVOKED
  4. #include <string.h>
  5. #include "../common/input.h"
  6. #include "../common/emu.h" // array_size
  7. #include "in_vk.h"
  8. #define IN_VK_PREFIX "vk:"
  9. #define IN_VK_NKEYS 0x100
  10. static const char * const in_vk_prefix = IN_VK_PREFIX;
  11. static const char * const in_vk_keys[IN_VK_NKEYS] = {
  12. [0 ... (IN_VK_NKEYS - 1)] = NULL,
  13. [VK_LBUTTON] = "LBUTTON", [VK_RBUTTON] = "RBUTTON",
  14. [VK_TAB] = "TAB", [VK_RETURN] = "RETURN",
  15. [VK_SHIFT] = "SHIFT", [VK_CONTROL] = "CONTROL",
  16. [VK_LEFT] = "LEFT", [VK_UP] = "UP",
  17. [VK_RIGHT] = "RIGHT", [VK_DOWN] = "DOWN",
  18. [VK_SPACE] = "SPACE",
  19. };
  20. // additional player12 keys
  21. int in_vk_add_pl12;
  22. // up to 4, keyboards rarely allow more
  23. static int in_vk_keys_down[4];
  24. /*
  25. #define VK_END 35
  26. #define VK_HOME 36
  27. #define VK_INSERT 45
  28. #define VK_DELETE 46
  29. #define VK_NUMPAD0 0x60
  30. #define VK_NUMPAD1 0x61
  31. #define VK_NUMPAD2 0x62
  32. #define VK_NUMPAD3 0x63
  33. #define VK_NUMPAD4 0x64
  34. #define VK_NUMPAD5 0x65
  35. #define VK_NUMPAD6 0x66
  36. #define VK_NUMPAD7 0x67
  37. #define VK_NUMPAD8 0x68
  38. #define VK_NUMPAD9 0x69
  39. #define VK_MULTIPLY 0x6A
  40. #define VK_ADD 0x6B
  41. #define VK_SEPARATOR 0x6C
  42. #define VK_SUBTRACT 0x6D
  43. #define VK_DECIMAL 0x6E
  44. #define VK_DIVIDE 0x6F
  45. #define VK_F1 0x70
  46. #define VK_F2 0x71
  47. #define VK_F3 0x72
  48. #define VK_F4 0x73
  49. #define VK_F5 0x74
  50. #define VK_F6 0x75
  51. #define VK_F7 0x76
  52. #define VK_F8 0x77
  53. #define VK_F9 0x78
  54. #define VK_F10 0x79
  55. #define VK_F11 0x7A
  56. #define VK_F12 0x7B
  57. */
  58. static void in_vk_probe(void)
  59. {
  60. memset(in_vk_keys_down, 0, sizeof(in_vk_keys_down));
  61. in_register(IN_VK_PREFIX "vk", IN_DRVID_VK, -1, (void *)1, IN_VK_NKEYS, 0);
  62. }
  63. static int in_vk_get_bind_count(void)
  64. {
  65. return IN_VK_NKEYS;
  66. }
  67. /* ORs result with pressed buttons */
  68. int in_vk_update(void *drv_data, const int *binds, int *result)
  69. {
  70. int i, t, k;
  71. for (i = 0; i < array_size(in_vk_keys_down); i++) {
  72. k = in_vk_keys_down[i];
  73. if (!k)
  74. continue;
  75. for (t = 0; t < IN_BINDTYPE_COUNT; t++)
  76. result[t] |= binds[IN_BIND_OFFS(k, t)];
  77. }
  78. result[IN_BINDTYPE_PLAYER12] |= in_vk_add_pl12;
  79. return 0;
  80. }
  81. void in_vk_keydown(int kc)
  82. {
  83. int i;
  84. // search
  85. for (i = 0; i < array_size(in_vk_keys_down); i++)
  86. if (in_vk_keys_down[i] == kc)
  87. return;
  88. // do
  89. for (i = 0; i < array_size(in_vk_keys_down); i++) {
  90. if (in_vk_keys_down[i] == 0) {
  91. in_vk_keys_down[i] = kc;
  92. return;
  93. }
  94. }
  95. }
  96. void in_vk_keyup(int kc)
  97. {
  98. int i;
  99. for (i = 0; i < array_size(in_vk_keys_down); i++)
  100. if (in_vk_keys_down[i] == kc)
  101. in_vk_keys_down[i] = 0;
  102. }
  103. static int in_vk_update_keycode(void *data, int *is_down)
  104. {
  105. return 0;
  106. }
  107. static const struct {
  108. short key;
  109. short pbtn;
  110. } key_pbtn_map[] =
  111. {
  112. { VK_UP, PBTN_UP },
  113. { VK_DOWN, PBTN_DOWN },
  114. { VK_LEFT, PBTN_LEFT },
  115. { VK_RIGHT, PBTN_RIGHT },
  116. { VK_RETURN, PBTN_MOK },
  117. /*
  118. { BTN_X, PBTN_MBACK },
  119. { BTN_A, PBTN_MA2 },
  120. { BTN_Y, PBTN_MA3 },
  121. { BTN_L, PBTN_L },
  122. { BTN_R, PBTN_R },
  123. { BTN_SELECT, PBTN_MENU },
  124. */
  125. };
  126. #define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0]))
  127. static int in_vk_menu_translate(int keycode)
  128. {
  129. int i;
  130. if (keycode < 0)
  131. {
  132. /* menu -> kc */
  133. keycode = -keycode;
  134. for (i = 0; i < KEY_PBTN_MAP_SIZE; i++)
  135. if (key_pbtn_map[i].pbtn == keycode)
  136. return key_pbtn_map[i].key;
  137. }
  138. else
  139. {
  140. for (i = 0; i < KEY_PBTN_MAP_SIZE; i++)
  141. if (key_pbtn_map[i].key == keycode)
  142. return key_pbtn_map[i].pbtn;
  143. }
  144. return 0;
  145. }
  146. static int in_vk_get_key_code(const char *key_name)
  147. {
  148. int i;
  149. if (key_name[1] == 0 && 'A' <= key_name[0] && key_name[0] <= 'Z')
  150. return key_name[0];
  151. for (i = 0; i < IN_VK_NKEYS; i++) {
  152. const char *k = in_vk_keys[i];
  153. if (k != NULL && strcasecmp(k, key_name) == 0)
  154. return i;
  155. }
  156. return -1;
  157. }
  158. static const char *in_vk_get_key_name(int keycode)
  159. {
  160. const char *name = NULL;
  161. static char buff[4];
  162. if ('A' <= keycode && keycode < 'Z') {
  163. buff[0] = keycode;
  164. buff[1] = 0;
  165. return buff;
  166. }
  167. if (0 <= keycode && keycode < IN_VK_NKEYS)
  168. name = in_vk_keys[keycode];
  169. if (name == NULL)
  170. name = "Unkn";
  171. return name;
  172. }
  173. static const struct {
  174. short code;
  175. char btype;
  176. char bit;
  177. } in_vk_def_binds[] =
  178. {
  179. /* MXYZ SACB RLDU */
  180. { VK_UP, IN_BINDTYPE_PLAYER12, 0 },
  181. { VK_DOWN, IN_BINDTYPE_PLAYER12, 1 },
  182. { VK_LEFT, IN_BINDTYPE_PLAYER12, 2 },
  183. { VK_RIGHT, IN_BINDTYPE_PLAYER12, 3 },
  184. { 'S', IN_BINDTYPE_PLAYER12, 4 }, /* B */
  185. { 'D', IN_BINDTYPE_PLAYER12, 5 }, /* C */
  186. { 'A', IN_BINDTYPE_PLAYER12, 6 }, /* A */
  187. { VK_RETURN, IN_BINDTYPE_PLAYER12, 7 },
  188. { 'E', IN_BINDTYPE_PLAYER12, 8 }, /* Z */
  189. { 'W', IN_BINDTYPE_PLAYER12, 9 }, /* Y */
  190. { 'Q', IN_BINDTYPE_PLAYER12,10 }, /* X */
  191. { 'R', IN_BINDTYPE_PLAYER12,11 }, /* M */
  192. /*
  193. { BTN_SELECT, IN_BINDTYPE_EMU, PEVB_MENU },
  194. // { BTN_Y, IN_BINDTYPE_EMU, PEVB_SWITCH_RND },
  195. { BTN_L, IN_BINDTYPE_EMU, PEVB_STATE_SAVE },
  196. { BTN_R, IN_BINDTYPE_EMU, PEVB_STATE_LOAD },
  197. { BTN_VOL_UP, IN_BINDTYPE_EMU, PEVB_VOL_UP },
  198. { BTN_VOL_DOWN, IN_BINDTYPE_EMU, PEVB_VOL_DOWN },
  199. */
  200. };
  201. #define DEF_BIND_COUNT (sizeof(in_vk_def_binds) / sizeof(in_vk_def_binds[0]))
  202. static void in_vk_get_def_binds(int *binds)
  203. {
  204. int i;
  205. for (i = 0; i < DEF_BIND_COUNT; i++)
  206. binds[IN_BIND_OFFS(in_vk_def_binds[i].code, in_vk_def_binds[i].btype)] =
  207. 1 << in_vk_def_binds[i].bit;
  208. }
  209. /* remove binds of missing keys, count remaining ones */
  210. static int in_vk_clean_binds(void *drv_data, int *binds, int *def_binds)
  211. {
  212. int i, count = 0;
  213. for (i = 0; i < IN_VK_NKEYS; i++) {
  214. int t, offs;
  215. for (t = 0; t < IN_BINDTYPE_COUNT; t++) {
  216. offs = IN_BIND_OFFS(i, t);
  217. if (strcmp(in_vk_get_key_name(i), "Unkn") == 0)
  218. binds[offs] = def_binds[offs] = 0;
  219. if (binds[offs])
  220. count++;
  221. }
  222. }
  223. return count;
  224. }
  225. void in_vk_init(void *vdrv)
  226. {
  227. in_drv_t *drv = vdrv;
  228. drv->prefix = in_vk_prefix;
  229. drv->probe = in_vk_probe;
  230. drv->get_bind_count = in_vk_get_bind_count;
  231. drv->get_def_binds = in_vk_get_def_binds;
  232. drv->clean_binds = in_vk_clean_binds;
  233. drv->menu_translate = in_vk_menu_translate;
  234. drv->get_key_code = in_vk_get_key_code;
  235. drv->get_key_name = in_vk_get_key_name;
  236. drv->update_keycode = in_vk_update_keycode;
  237. }