API tools faq
paste
Advertisement
Guest User

in_sdl.c

a guest
Dec 4th, 2018
90
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 29.50 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/in_sdl.c b/in_sdl.c
  2. index 046f92d..9b99788 100644
  3. --- a/in_sdl.c
  4. +++ b/in_sdl.c
  5. @@ -11,8 +11,19 @@
  6.  
  7.  #include <stdio.h>
  8.  #include <SDL.h>
  9. +#include <sys/types.h>
  10. +#include <sys/stat.h>
  11. +#include <fcntl.h>
  12. +
  13.  #include "input.h"
  14.  #include "in_sdl.h"
  15. +#if SDL_MAJOR_VERSION == 2
  16. +#include "keysym.h"
  17. +typedef int bool;
  18. +#define true 1
  19. +#define false 0
  20. +//#define CONFIG_DEBUG
  21. +#endif
  22.  
  23.  #define IN_SDL_PREFIX "sdl:"
  24.  /* should be machine word for best performace */
  25. @@ -29,6 +40,422 @@ struct in_sdl_state {
  26.  
  27.  static void (*ext_event_handler)(void *event);
  28.  
  29. +#if SDL_MAJOR_VERSION == 2
  30. +SDLK_to_MY_SDLK SDLK_to_My_SDLK_ARRAY[] = {
  31. +  {SDLK_UNKNOWN,  MY_SDLK_UNKNOWN},
  32. +
  33. +  {SDLK_RETURN, MY_SDLK_RETURN},
  34. +  {SDLK_ESCAPE, MY_SDLK_ESCAPE},
  35. +  {SDLK_BACKSPACE, MY_SDLK_BACKSPACE},
  36. +  {SDLK_TAB, MY_SDLK_TAB},
  37. +  {SDLK_SPACE, MY_SDLK_SPACE},
  38. +  {SDLK_EXCLAIM, MY_SDLK_EXCLAIM},
  39. +  {SDLK_QUOTEDBL, MY_SDLK_QUOTEDBL},
  40. +  {SDLK_HASH, MY_SDLK_HASH},
  41. +  {SDLK_PERCENT, MY_SDLK_PERCENT},
  42. +  {SDLK_DOLLAR, MY_SDLK_DOLLAR},
  43. +  {SDLK_AMPERSAND, MY_SDLK_AMPERSAND},
  44. +  {SDLK_QUOTE, MY_SDLK_QUOTE},
  45. +  {SDLK_LEFTPAREN, MY_SDLK_LEFTPAREN},
  46. +  {SDLK_RIGHTPAREN, MY_SDLK_RIGHTPAREN},
  47. +  {SDLK_ASTERISK, MY_SDLK_ASTERISK},
  48. +  {SDLK_PLUS, MY_SDLK_PLUS},
  49. +  {SDLK_COMMA, MY_SDLK_COMMA},
  50. +  {SDLK_MINUS, MY_SDLK_MINUS},
  51. +  {SDLK_PERIOD, MY_SDLK_PERIOD},
  52. +  {SDLK_SLASH, MY_SDLK_SLASH},
  53. +  {SDLK_0, MY_SDLK_0},
  54. +  {SDLK_1, MY_SDLK_1},
  55. +  {SDLK_2, MY_SDLK_2},
  56. +  {SDLK_3, MY_SDLK_3},
  57. +  {SDLK_4, MY_SDLK_4},
  58. +  {SDLK_5, MY_SDLK_5},
  59. +  {SDLK_6, MY_SDLK_6},
  60. +  {SDLK_7, MY_SDLK_7},
  61. +  {SDLK_8, MY_SDLK_8},
  62. +  {SDLK_9, MY_SDLK_9},
  63. +  {SDLK_COLON, MY_SDLK_COLON},
  64. +  {SDLK_SEMICOLON, MY_SDLK_SEMICOLON},
  65. +  {SDLK_LESS, MY_SDLK_LESS},
  66. +  {SDLK_EQUALS, MY_SDLK_EQUALS},
  67. +  {SDLK_GREATER, MY_SDLK_GREATER},
  68. +  {SDLK_QUESTION, MY_SDLK_QUESTION},
  69. +  {SDLK_AT, MY_SDLK_AT},
  70. +  /*
  71. +    Skip uppercase letters
  72. +  */
  73. +  {SDLK_LEFTBRACKET, MY_SDLK_LEFTBRACKET},
  74. +  {SDLK_BACKSLASH, MY_SDLK_BACKSLASH},
  75. +  {SDLK_RIGHTBRACKET, MY_SDLK_RIGHTBRACKET},
  76. +  {SDLK_CARET, MY_SDLK_CARET},
  77. +  {SDLK_UNDERSCORE, MY_SDLK_UNDERSCORE},
  78. +  {SDLK_BACKQUOTE, MY_SDLK_BACKQUOTE},
  79. +  {SDLK_a, MY_SDLK_a},
  80. +  {SDLK_b, MY_SDLK_b},
  81. +  {SDLK_c, MY_SDLK_c},
  82. +  {SDLK_d, MY_SDLK_d},
  83. +  {SDLK_e, MY_SDLK_e},
  84. +  {SDLK_f, MY_SDLK_f},
  85. +  {SDLK_g, MY_SDLK_g},
  86. +  {SDLK_h, MY_SDLK_h},
  87. +  {SDLK_i, MY_SDLK_i},
  88. +  {SDLK_j, MY_SDLK_j},
  89. +  {SDLK_k, MY_SDLK_k},
  90. +  {SDLK_l, MY_SDLK_l},
  91. +  {SDLK_m, MY_SDLK_m},
  92. +  {SDLK_n, MY_SDLK_n},
  93. +  {SDLK_o, MY_SDLK_o},
  94. +  {SDLK_p, MY_SDLK_p},
  95. +  {SDLK_q, MY_SDLK_q},
  96. +  {SDLK_r, MY_SDLK_r},
  97. +  {SDLK_s, MY_SDLK_s},
  98. +  {SDLK_t, MY_SDLK_t},
  99. +  {SDLK_u, MY_SDLK_u},
  100. +  {SDLK_v, MY_SDLK_v},
  101. +  {SDLK_w, MY_SDLK_w},
  102. +  {SDLK_x, MY_SDLK_x},
  103. +  {SDLK_y, MY_SDLK_y},
  104. +  {SDLK_z, MY_SDLK_z},
  105. +
  106. +  {SDLK_CAPSLOCK, MY_SDLK_CAPSLOCK},
  107. +
  108. +  {SDLK_F1, MY_SDLK_F1},
  109. +  {SDLK_F2, MY_SDLK_F2},
  110. +  {SDLK_F3, MY_SDLK_F3},
  111. +  {SDLK_F4, MY_SDLK_F4},
  112. +  {SDLK_F5, MY_SDLK_F5},
  113. +  {SDLK_F6, MY_SDLK_F6},
  114. +  {SDLK_F7, MY_SDLK_F7},
  115. +  {SDLK_F8, MY_SDLK_F8},
  116. +  {SDLK_F9, MY_SDLK_F9},
  117. +  {SDLK_F10, MY_SDLK_F10},
  118. +  {SDLK_F11, MY_SDLK_F11},
  119. +  {SDLK_F12, MY_SDLK_F12},
  120. +
  121. +  {SDLK_PRINTSCREEN, MY_SDLK_PRINTSCREEN},
  122. +  {SDLK_SCROLLLOCK, MY_SDLK_SCROLLLOCK},
  123. +  {SDLK_PAUSE, MY_SDLK_PAUSE},
  124. +  {SDLK_INSERT, MY_SDLK_INSERT},
  125. +  {SDLK_HOME, MY_SDLK_HOME},
  126. +  {SDLK_PAGEUP, MY_SDLK_PAGEUP},
  127. +  {SDLK_DELETE, MY_SDLK_DELETE},
  128. +  {SDLK_END, MY_SDLK_END},
  129. +  {SDLK_PAGEDOWN, MY_SDLK_PAGEDOWN},
  130. +  {SDLK_RIGHT, MY_SDLK_RIGHT},
  131. +  {SDLK_LEFT, MY_SDLK_LEFT},
  132. +  {SDLK_DOWN, MY_SDLK_DOWN},
  133. +  {SDLK_UP, MY_SDLK_UP},
  134. +
  135. +  {SDLK_NUMLOCKCLEAR, MY_SDLK_NUMLOCKCLEAR},
  136. +  {SDLK_KP_DIVIDE, MY_SDLK_KP_DIVIDE},
  137. +  {SDLK_KP_MULTIPLY, MY_SDLK_KP_MULTIPLY},
  138. +  {SDLK_KP_MINUS, MY_SDLK_KP_MINUS},
  139. +  {SDLK_KP_PLUS, MY_SDLK_KP_PLUS},
  140. +  {SDLK_KP_ENTER, MY_SDLK_KP_ENTER},
  141. +  {SDLK_KP_1, MY_SDLK_KP_1},
  142. +  {SDLK_KP_2, MY_SDLK_KP_2},
  143. +  {SDLK_KP_3, MY_SDLK_KP_3},
  144. +  {SDLK_KP_4, MY_SDLK_KP_4},
  145. +  {SDLK_KP_5, MY_SDLK_KP_5},
  146. +  {SDLK_KP_6, MY_SDLK_KP_6},
  147. +  {SDLK_KP_7, MY_SDLK_KP_7},
  148. +  {SDLK_KP_8, MY_SDLK_KP_8},
  149. +  {SDLK_KP_9, MY_SDLK_KP_9},
  150. +  {SDLK_KP_0, MY_SDLK_KP_0},
  151. +  {SDLK_KP_PERIOD, MY_SDLK_KP_PERIOD},
  152. +
  153. +  {SDLK_APPLICATION, MY_SDLK_APPLICATION},
  154. +  {SDLK_POWER, MY_SDLK_POWER},
  155. +  {SDLK_KP_EQUALS, MY_SDLK_KP_EQUALS},
  156. +  {SDLK_F13, MY_SDLK_F13},
  157. +  {SDLK_F14, MY_SDLK_F14},
  158. +  {SDLK_F15, MY_SDLK_F15},
  159. +  {SDLK_F16, MY_SDLK_F16},
  160. +  {SDLK_F17, MY_SDLK_F17},
  161. +  {SDLK_F18, MY_SDLK_F18},
  162. +  {SDLK_F19, MY_SDLK_F19},
  163. +  {SDLK_F20, MY_SDLK_F20},
  164. +  {SDLK_F21, MY_SDLK_F21},
  165. +  {SDLK_F22, MY_SDLK_F22},
  166. +  {SDLK_F23, MY_SDLK_F23},
  167. +  {SDLK_F24, MY_SDLK_F24},
  168. +  {SDLK_EXECUTE, MY_SDLK_EXECUTE},
  169. +  {SDLK_HELP, MY_SDLK_HELP},
  170. +  {SDLK_MENU, MY_SDLK_MENU},
  171. +  {SDLK_SELECT, MY_SDLK_SELECT},
  172. +  {SDLK_STOP, MY_SDLK_STOP},
  173. +  {SDLK_AGAIN, MY_SDLK_AGAIN},
  174. +  {SDLK_UNDO, MY_SDLK_UNDO},
  175. +  {SDLK_CUT, MY_SDLK_CUT},
  176. +  {SDLK_COPY, MY_SDLK_COPY},
  177. +  {SDLK_PASTE, MY_SDLK_PASTE},
  178. +  {SDLK_FIND, MY_SDLK_FIND},
  179. +  {SDLK_MUTE, MY_SDLK_MUTE},
  180. +  {SDLK_VOLUMEUP, MY_SDLK_VOLUMEUP},
  181. +  {SDLK_VOLUMEDOWN, MY_SDLK_VOLUMEDOWN},
  182. +  {SDLK_KP_COMMA, MY_SDLK_KP_COMMA},
  183. +  {SDLK_KP_EQUALSAS400, MY_SDLK_KP_EQUALSAS400},
  184. +
  185. +  {SDLK_ALTERASE, MY_SDLK_ALTERASE},
  186. +  {SDLK_SYSREQ, MY_SDLK_SYSREQ},
  187. +  {SDLK_CANCEL, MY_SDLK_CANCEL},
  188. +  {SDLK_CLEAR, MY_SDLK_CLEAR},
  189. +  {SDLK_PRIOR, MY_SDLK_PRIOR},
  190. +  {SDLK_RETURN2, MY_SDLK_RETURN2},
  191. +  {SDLK_SEPARATOR, MY_SDLK_SEPARATOR},
  192. +  {SDLK_OUT, MY_SDLK_OUT},
  193. +  {SDLK_OPER, MY_SDLK_OPER},
  194. +  {SDLK_CLEARAGAIN, MY_SDLK_CLEARAGAIN},
  195. +  {SDLK_CRSEL, MY_SDLK_CRSEL},
  196. +  {SDLK_EXSEL, MY_SDLK_EXSEL},
  197. +
  198. +  {SDLK_KP_00, MY_SDLK_KP_00},
  199. +  {SDLK_KP_000, MY_SDLK_KP_000},
  200. +  {SDLK_THOUSANDSSEPARATOR, MY_SDLK_THOUSANDSSEPARATOR},
  201. +  {SDLK_DECIMALSEPARATOR, MY_SDLK_DECIMALSEPARATOR},
  202. +  {SDLK_CURRENCYUNIT, MY_SDLK_CURRENCYUNIT},
  203. +  {SDLK_CURRENCYSUBUNIT, MY_SDLK_CURRENCYSUBUNIT},
  204. +  {SDLK_KP_LEFTPAREN, MY_SDLK_KP_LEFTPAREN},
  205. +  {SDLK_KP_RIGHTPAREN, MY_SDLK_KP_RIGHTPAREN},
  206. +  {SDLK_KP_LEFTBRACE, MY_SDLK_KP_LEFTBRACE},
  207. +  {SDLK_KP_RIGHTBRACE, MY_SDLK_KP_RIGHTBRACE},
  208. +  {SDLK_KP_TAB, MY_SDLK_KP_TAB},
  209. +  {SDLK_KP_BACKSPACE, MY_SDLK_KP_BACKSPACE},
  210. +  {SDLK_KP_A, MY_SDLK_KP_A},
  211. +  {SDLK_KP_B, MY_SDLK_KP_B},
  212. +  {SDLK_KP_C, MY_SDLK_KP_C},
  213. +  {SDLK_KP_D, MY_SDLK_KP_D},
  214. +  {SDLK_KP_E, MY_SDLK_KP_E},
  215. +  {SDLK_KP_F, MY_SDLK_KP_F},
  216. +  {SDLK_KP_XOR, MY_SDLK_KP_XOR},
  217. +  {SDLK_KP_POWER, MY_SDLK_KP_POWER},
  218. +  {SDLK_KP_PERCENT, MY_SDLK_KP_PERCENT},
  219. +  {SDLK_KP_LESS, MY_SDLK_KP_LESS},
  220. +  {SDLK_KP_GREATER, MY_SDLK_KP_GREATER},
  221. +  {SDLK_KP_AMPERSAND, MY_SDLK_KP_AMPERSAND},
  222. +  {SDLK_KP_DBLAMPERSAND, MY_SDLK_KP_DBLAMPERSAND},
  223. +  {SDLK_KP_VERTICALBAR, MY_SDLK_KP_VERTICALBAR},
  224. +  {SDLK_KP_DBLVERTICALBAR, MY_SDLK_KP_DBLVERTICALBAR},
  225. +  {SDLK_KP_COLON, MY_SDLK_KP_COLON},
  226. +  {SDLK_KP_HASH, MY_SDLK_KP_HASH},
  227. +  {SDLK_KP_SPACE, MY_SDLK_KP_SPACE},
  228. +  {SDLK_KP_AT, MY_SDLK_KP_AT},
  229. +  {SDLK_KP_EXCLAM, MY_SDLK_KP_EXCLAM},
  230. +  {SDLK_KP_MEMSTORE, MY_SDLK_KP_MEMSTORE},
  231. +  {SDLK_KP_MEMRECALL, MY_SDLK_KP_MEMRECALL},
  232. +  {SDLK_KP_MEMCLEAR, MY_SDLK_KP_MEMCLEAR},
  233. +  {SDLK_KP_MEMADD, MY_SDLK_KP_MEMADD},
  234. +  {SDLK_KP_MEMSUBTRACT, MY_SDLK_KP_MEMSUBTRACT},
  235. +  {SDLK_KP_MEMMULTIPLY, MY_SDLK_KP_MEMMULTIPLY},
  236. +  {SDLK_KP_MEMDIVIDE, MY_SDLK_KP_MEMDIVIDE},
  237. +  {SDLK_KP_PLUSMINUS, MY_SDLK_KP_PLUSMINUS},
  238. +  {SDLK_KP_CLEAR, MY_SDLK_KP_CLEAR},
  239. +  {SDLK_KP_CLEARENTRY, MY_SDLK_KP_CLEARENTRY},
  240. +  {SDLK_KP_BINARY, MY_SDLK_KP_BINARY},
  241. +  {SDLK_KP_OCTAL, MY_SDLK_KP_OCTAL},
  242. +  {SDLK_KP_DECIMAL, MY_SDLK_KP_DECIMAL},
  243. +  {SDLK_KP_HEXADECIMAL, MY_SDLK_KP_HEXADECIMAL},
  244. +
  245. +  {SDLK_LCTRL, MY_SDLK_LCTRL},
  246. +  {SDLK_LSHIFT, MY_SDLK_LSHIFT},
  247. +  {SDLK_LALT, MY_SDLK_LALT},
  248. +  {SDLK_LGUI, MY_SDLK_LGUI},
  249. +  {SDLK_RCTRL, MY_SDLK_RCTRL},
  250. +  {SDLK_RSHIFT, MY_SDLK_RSHIFT},
  251. +  {SDLK_RALT, MY_SDLK_RALT},
  252. +  {SDLK_RGUI, MY_SDLK_RGUI},
  253. +
  254. +  {SDLK_MODE, MY_SDLK_MODE},
  255. +
  256. +  {SDLK_AUDIONEXT, MY_SDLK_AUDIONEXT},
  257. +  {SDLK_AUDIOPREV, MY_SDLK_AUDIOPREV},
  258. +  {SDLK_AUDIOSTOP, MY_SDLK_AUDIOSTOP},
  259. +  {SDLK_AUDIOPLAY, MY_SDLK_AUDIOPLAY},
  260. +  {SDLK_AUDIOMUTE, MY_SDLK_AUDIOMUTE},
  261. +  {SDLK_MEDIASELECT, MY_SDLK_MEDIASELECT},
  262. +  {SDLK_WWW, MY_SDLK_WWW},
  263. +  {SDLK_MAIL, MY_SDLK_MAIL},
  264. +  {SDLK_CALCULATOR, MY_SDLK_CALCULATOR},
  265. +  {SDLK_COMPUTER, MY_SDLK_COMPUTER},
  266. +  {SDLK_AC_SEARCH, MY_SDLK_AC_SEARCH},
  267. +  {SDLK_AC_HOME, MY_SDLK_AC_HOME},
  268. +  {SDLK_AC_BACK, MY_SDLK_AC_BACK},
  269. +  {SDLK_AC_FORWARD, MY_SDLK_AC_FORWARD},
  270. +  {SDLK_AC_STOP, MY_SDLK_AC_STOP},
  271. +  {SDLK_AC_REFRESH, MY_SDLK_AC_REFRESH},
  272. +  {SDLK_AC_BOOKMARKS, MY_SDLK_AC_BOOKMARKS},
  273. +
  274. +  {SDLK_BRIGHTNESSDOWN, MY_SDLK_BRIGHTNESSDOWN},
  275. +  {SDLK_BRIGHTNESSUP, MY_SDLK_BRIGHTNESSUP},
  276. +  {SDLK_DISPLAYSWITCH, MY_SDLK_DISPLAYSWITCH},
  277. +  {SDLK_KBDILLUMTOGGLE, MY_SDLK_KBDILLUMTOGGLE},
  278. +  {SDLK_KBDILLUMDOWN, MY_SDLK_KBDILLUMDOWN},
  279. +  {SDLK_KBDILLUMUP, MY_SDLK_KBDILLUMUP},
  280. +  {SDLK_EJECT, MY_SDLK_EJECT},
  281. +  {SDLK_SLEEP, MY_SDLK_SLEEP},
  282. +  //{SDLK_APP1, MY_SDLK_APP1},
  283. +  //{SDLK_APP2, MY_SDLK_APP2},
  284. +
  285. +  //{SDLK_AUDIOREWIND, MY_SDLK_AUDIOREWIND},
  286. +  //{SDLK_AUDIOFASTFORWARD, MY_SDLK_AUDIOFASTFORWARD},
  287. +
  288. +  {SDLK_LAST, MY_SDLK_UNKNOWN}
  289. +};    
  290. +
  291. +static int func_SDLK_TO_MY_SDLK(int argSDLK) {
  292. +  int i = 0;
  293. +  
  294. +  do {
  295. +    if(SDLK_to_My_SDLK_ARRAY[i].m_SDLK == argSDLK) {
  296. +      break;
  297. +    }
  298. +    i++;
  299. +  } while(SDLK_to_My_SDLK_ARRAY[i].m_SDLK != SDLK_LAST);
  300. +  return SDLK_to_My_SDLK_ARRAY[i].m_MySDLK;
  301. +}
  302. +
  303. +// SDL1???????????????????????????????????????????????????
  304. +static const char * const in_sdl_keys[SDLK_LAST] = {
  305. +        [MY_SDLK_BACKSPACE] = "backspace",
  306. +   [MY_SDLK_TAB] = "tab",
  307. +   [MY_SDLK_CLEAR] = "clear",
  308. +   [MY_SDLK_RETURN] = "return",
  309. +   [MY_SDLK_PAUSE] = "pause",
  310. +   [MY_SDLK_ESCAPE] = "escape",
  311. +   [MY_SDLK_SPACE] = "space",
  312. +   [MY_SDLK_EXCLAIM]  = "!",
  313. +   [MY_SDLK_QUOTEDBL]  = "\"",
  314. +   [MY_SDLK_HASH]  = "#",
  315. +   [MY_SDLK_DOLLAR]  = "$",
  316. +   [MY_SDLK_AMPERSAND]  = "&",
  317. +   [MY_SDLK_QUOTE] = "'",
  318. +   [MY_SDLK_LEFTPAREN] = "(",
  319. +   [MY_SDLK_RIGHTPAREN] = ")",
  320. +   [MY_SDLK_ASTERISK] = "*",
  321. +   [MY_SDLK_PLUS] = "+",
  322. +   [MY_SDLK_COMMA] = ",",
  323. +   [MY_SDLK_MINUS] = "-",
  324. +   [MY_SDLK_PERIOD] = ".",
  325. +   [MY_SDLK_SLASH] = "/",
  326. +   [MY_SDLK_0] = "0",
  327. +   [MY_SDLK_1] = "1",
  328. +   [MY_SDLK_2] = "2",
  329. +   [MY_SDLK_3] = "3",
  330. +   [MY_SDLK_4] = "4",
  331. +   [MY_SDLK_5] = "5",
  332. +   [MY_SDLK_6] = "6",
  333. +   [MY_SDLK_7] = "7",
  334. +   [MY_SDLK_8] = "8",
  335. +   [MY_SDLK_9] = "9",
  336. +   [MY_SDLK_COLON] = ":",
  337. +   [MY_SDLK_SEMICOLON] = ";",
  338. +   [MY_SDLK_LESS] = "<",
  339. +   [MY_SDLK_EQUALS] = "=",
  340. +   [MY_SDLK_GREATER] = ">",
  341. +   [MY_SDLK_QUESTION] = "?",
  342. +   [MY_SDLK_AT] = "@",
  343. +   [MY_SDLK_LEFTBRACKET] = "[",
  344. +   [MY_SDLK_BACKSLASH] = "\\",
  345. +   [MY_SDLK_RIGHTBRACKET] = "]",
  346. +   [MY_SDLK_CARET] = "^",
  347. +   [MY_SDLK_UNDERSCORE] = "_",
  348. +   [MY_SDLK_BACKQUOTE] = "`",
  349. +   [MY_SDLK_a] = "a",
  350. +   [MY_SDLK_b] = "b",
  351. +   [MY_SDLK_c] = "c",
  352. +   [MY_SDLK_d] = "d",
  353. +   [MY_SDLK_e] = "e",
  354. +   [MY_SDLK_f] = "f",
  355. +   [MY_SDLK_g] = "g",
  356. +   [MY_SDLK_h] = "h",
  357. +   [MY_SDLK_i] = "i",
  358. +   [MY_SDLK_j] = "j",
  359. +   [MY_SDLK_k] = "k",
  360. +   [MY_SDLK_l] = "l",
  361. +   [MY_SDLK_m] = "m",
  362. +   [MY_SDLK_n] = "n",
  363. +   [MY_SDLK_o] = "o",
  364. +   [MY_SDLK_p] = "p",
  365. +   [MY_SDLK_q] = "q",
  366. +   [MY_SDLK_r] = "r",
  367. +   [MY_SDLK_s] = "s",
  368. +   [MY_SDLK_t] = "t",
  369. +   [MY_SDLK_u] = "u",
  370. +   [MY_SDLK_v] = "v",
  371. +   [MY_SDLK_w] = "w",
  372. +   [MY_SDLK_x] = "x",
  373. +   [MY_SDLK_y] = "y",
  374. +   [MY_SDLK_z] = "z",
  375. +   [MY_SDLK_DELETE] = "delete",
  376. +
  377. +   [MY_SDLK_KP_0] = "[0]",
  378. +   [MY_SDLK_KP_1] = "[1]",
  379. +   [MY_SDLK_KP_2] = "[2]",
  380. +   [MY_SDLK_KP_3] = "[3]",
  381. +   [MY_SDLK_KP_4] = "[4]",
  382. +   [MY_SDLK_KP_5] = "[5]",
  383. +   [MY_SDLK_KP_6] = "[6]",
  384. +   [MY_SDLK_KP_7] = "[7]",
  385. +   [MY_SDLK_KP_8] = "[8]",
  386. +   [MY_SDLK_KP_9] = "[9]",
  387. +   [MY_SDLK_KP_PERIOD] = "[.]",
  388. +   [MY_SDLK_KP_DIVIDE] = "[/]",
  389. +   [MY_SDLK_KP_MULTIPLY] = "[*]",
  390. +   [MY_SDLK_KP_MINUS] = "[-]",
  391. +   [MY_SDLK_KP_PLUS] = "[+]",
  392. +   [MY_SDLK_KP_ENTER] = "enter",
  393. +   [MY_SDLK_KP_EQUALS] = "equals",
  394. +
  395. +   [MY_SDLK_UP] = "up",
  396. +   [MY_SDLK_DOWN] = "down",
  397. +   [MY_SDLK_RIGHT] = "right",
  398. +   [MY_SDLK_LEFT] = "left",
  399. +   [MY_SDLK_INSERT] = "insert",
  400. +   [MY_SDLK_HOME] = "home",
  401. +   [MY_SDLK_END] = "end",
  402. +   [MY_SDLK_PAGEUP] = "page up",
  403. +   [MY_SDLK_PAGEDOWN] = "page down",
  404. +
  405. +   [MY_SDLK_F1] = "f1",
  406. +   [MY_SDLK_F2] = "f2",
  407. +   [MY_SDLK_F3] = "f3",
  408. +   [MY_SDLK_F4] = "f4",
  409. +   [MY_SDLK_F5] = "f5",
  410. +   [MY_SDLK_F6] = "f6",
  411. +   [MY_SDLK_F7] = "f7",
  412. +   [MY_SDLK_F8] = "f8",
  413. +   [MY_SDLK_F9] = "f9",
  414. +   [MY_SDLK_F10] = "f10",
  415. +   [MY_SDLK_F11] = "f11",
  416. +   [MY_SDLK_F12] = "f12",
  417. +   [MY_SDLK_F13] = "f13",
  418. +   [MY_SDLK_F14] = "f14",
  419. +   [MY_SDLK_F15] = "f15",
  420. +
  421. +   [MY_SDLK_NUMLOCKCLEAR] = "numlock",
  422. +   [MY_SDLK_CAPSLOCK] = "caps lock",
  423. +   [MY_SDLK_SCROLLLOCK] = "scroll lock",
  424. +   [MY_SDLK_RSHIFT] = "right shift",
  425. +   [MY_SDLK_LSHIFT] = "left shift",
  426. +   [MY_SDLK_RCTRL] = "right ctrl",
  427. +   [MY_SDLK_LCTRL] = "left ctrl",
  428. +   [MY_SDLK_RALT] = "right alt",
  429. +   [MY_SDLK_LALT] = "left alt",
  430. +#ifdef NOTDEF
  431. +   [MY_SDLK_RMETA] = "right meta",
  432. +   [MY_SDLK_LMETA] = "left meta",
  433. +   [MY_SDLK_LSUPER] = "left super",    /* "Windows" keys */
  434. +   [MY_SDLK_RSUPER] = "right super",  
  435. +#endif
  436. +   [MY_SDLK_MODE] = "alt gr",
  437. +#ifdef NOTDEF
  438. +   [MY_SDLK_COMPOSE] = "compose",
  439. +#endif
  440. +   [MY_SDLK_EJECT] = "eject",
  441. +   [MY_SDLK_SLEEP] = "sleep",
  442. +   [MY_SDLK_AUDIOPLAY] = "reset",
  443. +};
  444. +#else
  445.  static const char * const in_sdl_keys[SDLK_LAST] = {
  446.     [SDLK_BACKSPACE] = "backspace",
  447.     [SDLK_TAB] = "tab",
  448. @@ -161,7 +588,11 @@ static const char * const in_sdl_keys[SDLK_LAST] = {
  449.     [SDLK_RSUPER] = "right super", 
  450.     [SDLK_MODE] = "alt gr",
  451.     [SDLK_COMPOSE] = "compose",
  452. +   [SDLK_EJECT] = "eject",
  453. +   [SDLK_SLEEP] = "sleep",
  454. +   [SDLK_AUDIOPLAY] = "reset",
  455.  };
  456. +#endif
  457.  
  458.  static void in_sdl_probe(const in_drv_t *drv)
  459.  {
  460. @@ -171,7 +602,7 @@ static void in_sdl_probe(const in_drv_t *drv)
  461.     SDL_Joystick *joy;
  462.     int i, joycount;
  463.     char name[256];
  464. -
  465. +  
  466.     if (pdata->key_names)
  467.         key_names = pdata->key_names;
  468.  
  469. @@ -188,6 +619,15 @@ static void in_sdl_probe(const in_drv_t *drv)
  470.     /* joysticks go here too */
  471.     SDL_InitSubSystem(SDL_INIT_JOYSTICK);
  472.  
  473. +   int fd0 = open("/dev/input/joystick0",O_RDONLY);
  474. +    int fd1 = open("/dev/input/joystick1",O_RDONLY);
  475. +
  476. +   if( fd1 != -1 ){
  477. +       p2_connected = 1;
  478. +   }else{
  479. +       p2_connected = 0;
  480. +   }
  481. +  
  482.     joycount = SDL_NumJoysticks();
  483.     for (i = 0; i < joycount; i++) {
  484.         joy = SDL_JoystickOpen(i);
  485. @@ -203,12 +643,28 @@ static void in_sdl_probe(const in_drv_t *drv)
  486.         state->joy_id = i;
  487.         state->drv = drv;
  488.  
  489. +#if SDL_MAJOR_VERSION == 2
  490. +
  491. +       if(fd1 != -1 && fd0 == -1) {
  492. +           snprintf(name, sizeof(name), IN_SDL_PREFIX "%s [%d]", SDL_JoystickName(joy), 1);
  493. +       } else {
  494. +           snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(joy));
  495. +       }
  496. +      
  497. +#else
  498.         snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
  499. +#endif
  500.         in_register(name, -1, state, SDLK_LAST, key_names, 0);
  501.     }
  502.  
  503. +   if(fd0 != -1)
  504. +       close(fd0);
  505. +    if(fd1 != -1)
  506. +       close(fd1);
  507. +
  508.     if (joycount > 0)
  509.         SDL_JoystickEventState(SDL_ENABLE);
  510. +
  511.  }
  512.  
  513.  static void in_sdl_free(void *drv_data)
  514. @@ -236,7 +692,7 @@ in_sdl_get_key_names(const in_drv_t *drv, int *count)
  515.  /* could use SDL_GetKeyState, but this gives better packing */
  516.  static void update_keystate(keybits_t *keystate, int sym, int is_down)
  517.  {
  518. -   keybits_t *ks_word, mask;
  519. +        keybits_t *ks_word, mask;
  520.  
  521.     mask = 1;
  522.     mask <<= sym & (KEYBITS_WORD_BITS - 1);
  523. @@ -271,6 +727,14 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  524.     /* TODO: remaining axis */
  525.     switch (event->type) {
  526.     case SDL_JOYAXISMOTION:
  527. +#ifdef CONFIG_DEBUG
  528. +     printf("%s:%d SDL_JOYAXISMOTION which=%d axis=%d value=%d\n",
  529. +        __func__,
  530. +        __LINE__,
  531. +        event->jaxis.which,
  532. +        event->jaxis.axis,
  533. +        event->jaxis.value);
  534. +#endif
  535.         if (event->jaxis.which != state->joy_id)
  536.             return -2;
  537.         if (event->jaxis.axis > 1)
  538. @@ -284,7 +748,11 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  539.             kc = state->axis_keydown[event->jaxis.axis];
  540.             if (kc)
  541.                 update_keystate(state->keystate, kc, 0);
  542. +#if SDL_MAJOR_VERSION == 2
  543. +           kc = event->jaxis.axis ? MY_SDLK_UP : MY_SDLK_LEFT;
  544. +#else
  545.             kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
  546. +#endif
  547.             state->axis_keydown[event->jaxis.axis] = kc;
  548.             down = 1;
  549.             ret = 1;
  550. @@ -293,7 +761,11 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  551.             kc = state->axis_keydown[event->jaxis.axis];
  552.             if (kc)
  553.                 update_keystate(state->keystate, kc, 0);
  554. +#if SDL_MAJOR_VERSION == 2
  555. +           kc = event->jaxis.axis ? MY_SDLK_DOWN : MY_SDLK_RIGHT;
  556. +#else
  557.             kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
  558. +#endif
  559.             state->axis_keydown[event->jaxis.axis] = kc;
  560.             down = 1;
  561.             ret = 1;
  562. @@ -302,13 +774,31 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  563.  
  564.     case SDL_JOYBUTTONDOWN:
  565.     case SDL_JOYBUTTONUP:
  566. +#ifdef CONFIG_DEBUG
  567. +     printf("%s:%d SDL_JOYBUTTONxxxx which=%d button=%d\n",
  568. +        __func__,
  569. +        __LINE__,
  570. +        event->jbutton.which,
  571. +        event->jbutton.button);
  572. +#endif
  573.         if (event->jbutton.which != state->joy_id)
  574.             return -2;
  575. +#if SDL_MAJOR_VERSION == 2
  576. +       kc = (int)event->jbutton.button + MY_SDLK_WORLD_0;
  577. +#else
  578.         kc = (int)event->jbutton.button + SDLK_WORLD_0;
  579. +#endif
  580.         down = event->jbutton.state == SDL_PRESSED;
  581.         ret = 1;
  582.         break;
  583.     default:
  584. +#ifdef CONFIG_DEBUG
  585. +     printf("%s:%d event=0x%x(%d)\n",
  586. +        __func__,
  587. +        __LINE__,
  588. +        event->type,
  589. +        event->type);
  590. +#endif
  591.         return -1;
  592.     }
  593.  
  594. @@ -322,15 +812,254 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  595.     return ret;
  596.  }
  597.  
  598. +#if SDL_MAJOR_VERSION == 2
  599. +static void ControlJoysticEscape(struct in_sdl_state *arg_pState,
  600. +                SDL_Event *arg_pEvent)
  601. +{
  602. +  SDL_Event myEvent;
  603. +  static bool bIsCurrentSelectButtonDown = false;
  604. +  static bool bIsCurrentStartButtonDown = false;
  605. +
  606. +  bool bIsFormerSelectButtonDown = bIsCurrentSelectButtonDown;
  607. +  bool bIsFormerStartButtonDown = bIsCurrentStartButtonDown;
  608. +  char *env_menu, *endptr;
  609. +#ifdef CONFIG_ENABLE_MENU
  610. +  int env = 2;
  611. +#else
  612. +  int env = 0;
  613. +#endif
  614. +#ifdef CONFIG_DEBUG
  615. +       printf("%s:%d keysym.scancode=%d keysym.sym=%d keysym.mod=%d\n",
  616. +                                __func__,
  617. +                                __LINE__,
  618. +                                myEvent.key.keysym.scancode,
  619. +                                myEvent.key.keysym.sym,
  620. +                                myEvent.key.keysym.mod);
  621. +       printf("ControlJoysticEscape SDLK_WORLD %d",(arg_pEvent->jbutton.button + MY_SDLK_WORLD_0));
  622. +
  623. +#endif
  624. +
  625. +  if (arg_pState->joy) {
  626. +   env_menu = getenv("PCSX_ESC_KEY");
  627. +   if(env_menu != NULL) {
  628. +       env = strtol(env_menu, &endptr, 10);
  629. +       if(strlen(endptr) > 0 || env > 2) {
  630. +#ifdef CONFIG_ENABLE_MENU
  631. +         env = 2;
  632. +#else
  633. +         env = 0;
  634. +#endif
  635. +       }
  636. +   }
  637. +
  638. +   switch(env) {
  639. +    case 0:
  640. +      break;
  641. +    case 1:
  642. +      if((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_8) {
  643. +        // "select" key event
  644. +        switch (arg_pEvent->type) {
  645. +        case SDL_JOYBUTTONDOWN:
  646. +          bIsCurrentSelectButtonDown = true;
  647. +   break;
  648. +        case SDL_JOYBUTTONUP:
  649. +          bIsCurrentSelectButtonDown = false;
  650. +   break;
  651. +      }
  652. +
  653. +    } else if(((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_9)) {
  654. +      // "start" key event
  655. +      switch (arg_pEvent->type) {
  656. +      case SDL_JOYBUTTONDOWN:
  657. +   bIsCurrentStartButtonDown = true;
  658. +   break;
  659. +      case SDL_JOYBUTTONUP:
  660. +   bIsCurrentStartButtonDown = false;
  661. +   break;
  662. +      }
  663. +    }
  664. +
  665. +    if(!((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
  666. +       &&
  667. +       ((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
  668. +
  669. +        switch((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0)) {
  670. +           case MY_SDLK_WORLD_9:
  671. +#ifdef CONFIG_DEBUG
  672. +               printf("ControlJoysticEscape SDL_SCANCODE_ESCAPE - SDL_KEYDOWN");
  673. +#endif
  674. +               myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
  675. +               myEvent.key.keysym.sym = SDLK_ESCAPE;
  676. +               break;
  677. +        }
  678. +
  679. +      // make ESC-key/Open-key/Reset-key down event
  680. +      myEvent.type = myEvent.key.type = SDL_KEYDOWN;
  681. +      myEvent.key.timestamp = arg_pEvent->key.timestamp;
  682. +      myEvent.key.windowID = 1;
  683. +      myEvent.key.state = 1;
  684. +      myEvent.key.repeat = 0;
  685. +      myEvent.key.keysym.mod = 0;
  686. +
  687. +      SDL_PushEvent(&myEvent);
  688. +
  689. +    } else if(((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
  690. +         &&
  691. +         !((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
  692. +
  693. +      // make ESC-key up event
  694. +        switch((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0)) {
  695. +           case MY_SDLK_WORLD_9:
  696. +#ifdef CONFIG_DEBUG
  697. +                printf("ControlJoysticEscape SDL_SCANCODE_ESCAPE - SDL_KEYUP");
  698. +#endif
  699. +               myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
  700. +               myEvent.key.keysym.sym = SDLK_ESCAPE;
  701. +               break;
  702. +           case MY_SDLK_WORLD_0:
  703. +#ifdef CONFIG_DEBUG
  704. +                printf("ControlJoysticEscape SDL_SCANCODE_F9 - SDL_KEYUP");
  705. +#endif
  706. +               myEvent.key.keysym.scancode = SDL_SCANCODE_F9;
  707. +               myEvent.key.keysym.sym = SDLK_F9;
  708. +               break;
  709. +           case MY_SDLK_WORLD_1:
  710. +#ifdef CONFIG_DEBUG
  711. +                printf("ControlJoysticEscape SDL_SCANCODE_F10 - SDL_KEYUP");
  712. +#endif
  713. +               myEvent.key.keysym.scancode = SDL_SCANCODE_F10;
  714. +               myEvent.key.keysym.sym = SDLK_F10;
  715. +               break;
  716. +        }
  717. +
  718. +      // make ESC-key/Open-key/Reset-key up event
  719. +      myEvent.type = myEvent.key.type = SDL_KEYUP;
  720. +      myEvent.key.timestamp = arg_pEvent->key.timestamp;
  721. +      myEvent.key.windowID = 1;
  722. +      myEvent.key.state = 0;
  723. +      myEvent.key.repeat = 0;
  724. +      myEvent.key.keysym.mod = 0;
  725. +
  726. +      SDL_PushEvent(&myEvent);
  727. +    }
  728. +    break;
  729. +   case 2:
  730. +    if((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_8) {
  731. +      // "select" key event
  732. +      switch (arg_pEvent->type) {
  733. +      case SDL_JOYBUTTONDOWN:
  734. +        bIsCurrentSelectButtonDown = true;
  735. +        break;
  736. +      case SDL_JOYBUTTONUP:
  737. +        bIsCurrentSelectButtonDown = false;
  738. +        break;
  739. +      }
  740. +
  741. +    } else if(((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_0)) {
  742. +      // "tryangle" key event
  743. +      switch (arg_pEvent->type) {
  744. +      case SDL_JOYBUTTONDOWN:
  745. +        bIsCurrentStartButtonDown = true;
  746. +        break;
  747. +      case SDL_JOYBUTTONUP:
  748. +        bIsCurrentStartButtonDown = false;
  749. +        break;
  750. +      }
  751. +    }
  752. +
  753. +    if(!((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
  754. +       &&
  755. +       ((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
  756. +               myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
  757. +               myEvent.key.keysym.sym = SDLK_ESCAPE;
  758. +     myEvent.type = myEvent.key.type = SDL_KEYDOWN;
  759. +      myEvent.key.timestamp = arg_pEvent->key.timestamp;
  760. +      myEvent.key.windowID = 1;
  761. +      myEvent.key.state = 1;
  762. +      myEvent.key.repeat = 0;
  763. +      myEvent.key.keysym.mod = 0;
  764. +
  765. +      SDL_PushEvent(&myEvent);
  766. +
  767. +    } else if(((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
  768. +              &&
  769. +              !((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
  770. +               myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
  771. +               myEvent.key.keysym.sym = SDLK_ESCAPE;
  772. +
  773. +      // make ESC-key/Open-key/Reset-key up event
  774. +      myEvent.type = myEvent.key.type = SDL_KEYUP;
  775. +      myEvent.key.timestamp = arg_pEvent->key.timestamp;
  776. +      myEvent.key.windowID = 1;
  777. +      myEvent.key.state = 0;
  778. +      myEvent.key.repeat = 0;
  779. +      myEvent.key.keysym.mod = 0;
  780. +
  781. +      SDL_PushEvent(&myEvent);
  782. +    }
  783. +   default:
  784. +    break;
  785. +   }
  786. +  }
  787. +}
  788. +
  789. +#endif
  790. +#if SDL_MAJOR_VERSION == 1
  791.  #define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \
  792.             | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK)
  793. +#endif
  794.  
  795.  static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
  796.  {
  797.     SDL_Event events[4];
  798. +#ifdef CONFIG_DEBUG
  799. +   static int cnt=0;
  800. +#endif
  801. +#if SDL_MAJOR_VERSION == 1
  802.     Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
  803. +#else
  804. +   static int checkjoy0=0;
  805. +        int i=0, eventcnt=0;
  806. +   Uint32 minType;
  807. +   Uint32 maxType;
  808. +        eventcnt = SDL_PeepEvents(events,
  809. +                                  sizeof(events) / sizeof(events[0]),
  810. +                                  SDL_GETEVENT,
  811. +                                  SDL_JOYDEVICEADDED,
  812. +                                  SDL_JOYDEVICEREMOVED);
  813. +        if(eventcnt) {
  814. +#ifdef CONFIG_DEBUG
  815. +           printf("eventcnt : %d\n", eventcnt);
  816. +           printf("events->type : 0x%x\n", events->type);
  817. +           printf("jdevice.which : %d\n", events->jdevice.which);
  818. +#endif
  819. +           int check = 0;
  820. +       for(i=0; i < eventcnt; i++) {
  821. +                   check = bIsValidHotPlugEvent(&events[i]);
  822. +                       if(check) {
  823. +                           in_probe();
  824. +               }
  825. +           }
  826. +       SDL_PumpEvents();
  827. +       SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
  828. +       fflush(stdout);
  829. +       if (check) {
  830. +           // SDL_JOYDEVICEADDED or SDL_JOYDEVICEREMOVED ??????????????????
  831. +           // ????????????????????????????????????
  832. +           return -1;
  833. +       } else {
  834. +           for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
  835. +               if(state == NULL)
  836. +                   break;
  837. +               state->keystate[i] = 0;
  838. +           }
  839. +           return 0;
  840. +       }
  841. +   }
  842. +
  843. +#endif
  844.     int count, maxcount;
  845. -   int i, ret, retval = 0;
  846. +   int ret, retval = 0;
  847.     int num_events, num_peeped_events;
  848.     SDL_Event *event;
  849.  
  850. @@ -338,20 +1067,109 @@ static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down
  851.  
  852.     SDL_PumpEvents();
  853.  
  854. +#if SDL_MAJOR_VERSION == 2
  855. +   minType = SDL_KEYDOWN;
  856. +        maxType = SDL_KEYUP;
  857. +        if(state->joy) {
  858. +               minType = SDL_JOYAXISMOTION;
  859. +               maxType = SDL_JOYDEVICEREMOVED;
  860. +        }
  861. +   num_events = SDL_PeepEvents(NULL,
  862. +                   0,
  863. +                   SDL_PEEKEVENT,
  864. +                   minType,
  865. +                   maxType);
  866. +#ifdef CONFIG_DEBUG
  867. +   if(num_events) {
  868. +     printf("%s:%d %d joy=%p num_events=%d\n",__func__,__LINE__,++cnt,state->joy,num_events);
  869. +   }
  870. +#endif
  871. +#else
  872.     num_events = SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, mask);
  873. +#endif
  874.  
  875.     for (num_peeped_events = 0; num_peeped_events < num_events; num_peeped_events += count) {
  876. +#if SDL_MAJOR_VERSION == 2
  877. +           count = SDL_PeepEvents(events,
  878. +                      maxcount,
  879. +                      SDL_GETEVENT,
  880. +                      minType,
  881. +                      maxType);
  882. +#else
  883.         count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
  884. +#endif
  885.         if (count <= 0)
  886.             break;
  887.         for (i = 0; i < count; i++) {
  888.             event = &events[i];
  889. +#if SDL_MAJOR_VERSION == 2
  890. +           ControlJoysticEscape(state, event);
  891. +
  892. +           if (state->joy)
  893. +               ret = handle_joy_event(state,
  894. +                   event, one_kc, one_down);
  895. +           else {
  896. +#ifdef CONFIG_DEBUG
  897. +             printf("%s:%d type=0x%x key.type=0x%x timestamp=%d windowID=%d state=%d repeat=%d keysym.scancode=%d keysym.sym=%d keysym.mod=%d\n",
  898. +                __func__,
  899. +                __LINE__,
  900. +                event->type,
  901. +                event->key.type,
  902. +                event->key.timestamp,
  903. +                event->key.windowID,
  904. +                event->key.state,
  905. +                event->key.repeat,
  906. +                event->key.keysym.scancode,
  907. +                event->key.keysym.sym,
  908. +                event->key.keysym.mod);
  909. +#endif
  910. +                   event->key.keysym.sym = func_SDLK_TO_MY_SDLK(event->key.keysym.sym);
  911. +                   ret = handle_event(state,
  912. +                   event, one_kc, one_down);
  913. +           }
  914. +#ifdef CONFIG_DEBUG
  915. +           if(one_kc) {
  916. +             printf("%s:%d i=%d type(SDL_KEYDOWN or SDL_KEYUP)=0x%x timestamp=%d windowID=%d state(SDL_PRESSED or SDL_RELEASED)=%d repeat=%d one_key=0x%x(%d) scancode=0x%x(%d) sym=0x%x(%d) mod=%d\n" ,
  917. +                __func__,
  918. +                __LINE__,
  919. +                i,
  920. +                (event->key).type,            /* Uint32 */
  921. +                (event->key).timestamp,       /* Uint32 */
  922. +                (event->key).windowID,        /* Uint32 */
  923. +                (event->key).state,           /* Uint8 */
  924. +                (event->key).repeat,          /* Uint8 */
  925. +                *one_kc,
  926. +                *one_kc,
  927. +                (event->key).keysym.scancode, /* enum */
  928. +                (event->key).keysym.scancode, /* enum */
  929. +                (event->key).keysym.sym,      /* int32 */
  930. +                (event->key).keysym.sym,      /* int32 */
  931. +                (event->key).keysym.mod);     /* Uint16 */
  932. +           } else {
  933. +             printf("%s:%d i=%d type(SDL_KEYDOWN or SDL_KEYUP)=0x%x timestamp=%d windowID=%d state(SDL_PRESSED or SDL_RELEASED)=%d repeat=%d scancode=0x%x(%d) sym=0x%x(%d) mod=%d\n" ,
  934. +                __func__,
  935. +                __LINE__,
  936. +                i,
  937. +                (event->key).type,            /* Uint32 */
  938. +                (event->key).timestamp,       /* Uint32 */
  939. +                (event->key).windowID,        /* Uint32 */
  940. +                (event->key).state,           /* Uint8 */
  941. +                (event->key).repeat,          /* Uint8 */
  942. +                (event->key).keysym.scancode, /* enum */
  943. +                (event->key).keysym.scancode, /* enum */
  944. +                (event->key).keysym.sym,      /* int32 */
  945. +                (event->key).keysym.sym,      /* int32 */
  946. +                (event->key).keysym.mod);     /* Uint16 */
  947. +           }
  948. +#endif // #ifdef CONFIG_DEBUG
  949. +#else // #if SDL_MAJOR_VERSION == 2
  950.             if (state->joy)
  951.                 ret = handle_joy_event(state,
  952.                     event, one_kc, one_down);
  953.             else
  954.                 ret = handle_event(state,
  955.                     event, one_kc, one_down);
  956. +#endif // #if SDL_MAJOR_VERSION == 2
  957.             if (ret < 0) {
  958.                 switch (ret) {
  959.                     case -2:
  960. @@ -386,7 +1204,8 @@ static int in_sdl_update(void *drv_data, const int *binds, int *result)
  961.     keybits_t mask;
  962.     int i, sym, bit, b;
  963.  
  964. -   collect_events(state, NULL, NULL);
  965. +   if (collect_events(state, NULL, NULL) < 0)
  966. +       return 0;
  967.  
  968.     for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
  969.         mask = state->keystate[i];
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!