src/gmenu2x.cpp |
257 | 257 | if (confInt["backlightTimeout"] > 0) |
258 | 258 | PowerSaver::getInstance()->setScreenTimeout( confInt["backlightTimeout"] ); |
259 | 259 | |
260 | | setInputSpeed(); |
| 260 | SDL_EnableKeyRepeat(INPUT_KEY_REPEAT_DELAY, INPUT_KEY_REPEAT_RATE); |
261 | 261 | #ifdef ENABLE_CPUFREQ |
262 | 262 | setClock(confInt["menuClock"]); |
263 | 263 | #endif |
... | ... | |
1038 | 1038 | unsigned short remocon; |
1039 | 1039 | } MMSP2ADC; |
1040 | 1040 | |
1041 | | void GMenu2X::setInputSpeed() { |
1042 | | SDL_EnableKeyRepeat(250, 150); |
1043 | | } |
1044 | | |
1045 | 1041 | #ifdef ENABLE_CPUFREQ |
1046 | 1042 | void GMenu2X::setClock(unsigned mhz) { |
1047 | 1043 | mhz = constrain(mhz, cpuFreqMin, confInt["maxClock"]); |
src/inputmanager.cpp |
51 | 51 | for (i = 0; i < SDL_NumJoysticks(); i++) { |
52 | 52 | struct Joystick joystick = { |
53 | 53 | SDL_JoystickOpen(i), false, false, false, false, |
| 54 | SDL_HAT_CENTERED, nullptr, |
54 | 55 | }; |
55 | 56 | joysticks.push_back(joystick); |
56 | 57 | } |
... | ... | |
151 | 152 | source = KEYBOARD; |
152 | 153 | break; |
153 | 154 | #ifndef SDL_JOYSTICK_DISABLED |
154 | | case SDL_JOYHATMOTION: |
155 | | switch (event.jhat.value) { |
156 | | case SDL_HAT_CENTERED: |
157 | | return false; |
158 | | case SDL_HAT_UP: |
159 | | *button = UP; |
160 | | break; |
161 | | case SDL_HAT_DOWN: |
162 | | *button = DOWN; |
163 | | break; |
164 | | case SDL_HAT_LEFT: |
165 | | *button = LEFT; |
166 | | break; |
167 | | case SDL_HAT_RIGHT: |
168 | | *button = RIGHT; |
169 | | break; |
| 155 | case SDL_JOYHATMOTION: { |
| 156 | Joystick *joystick = &joysticks[event.jaxis.which]; |
| 157 | joystick->hatState = event.jhat.value; |
| 158 | |
| 159 | switch (event.jhat.value) { |
| 160 | case SDL_HAT_CENTERED: |
| 161 | stopTimer(joystick); |
| 162 | return false; |
| 163 | case SDL_HAT_UP: |
| 164 | *button = UP; |
| 165 | break; |
| 166 | case SDL_HAT_DOWN: |
| 167 | *button = DOWN; |
| 168 | break; |
| 169 | case SDL_HAT_LEFT: |
| 170 | *button = LEFT; |
| 171 | break; |
| 172 | case SDL_HAT_RIGHT: |
| 173 | *button = RIGHT; |
| 174 | break; |
| 175 | } |
| 176 | startTimer(joystick); |
170 | 177 | } |
171 | 178 | case SDL_JOYBUTTONDOWN: |
172 | 179 | source = JOYSTICK; |
... | ... | |
179 | 186 | if (axis > 1) |
180 | 187 | return false; |
181 | 188 | |
182 | | bool *axisState = joysticks[event.jaxis.which].axisState[axis]; |
| 189 | Joystick *joystick = &joysticks[event.jaxis.which]; |
| 190 | bool *axisState = joystick->axisState[axis]; |
183 | 191 | |
184 | 192 | if (event.jaxis.value < -20000) { |
185 | 193 | if (axisState[AXIS_STATE_NEGATIVE]) |
... | ... | |
194 | 202 | axisState[AXIS_STATE_POSITIVE] = true; |
195 | 203 | *button = axis ? DOWN : RIGHT; |
196 | 204 | } else { |
| 205 | bool *otherAxisState = joystick->axisState[!axis]; |
| 206 | if (!otherAxisState[AXIS_STATE_NEGATIVE] && |
| 207 | !otherAxisState[AXIS_STATE_POSITIVE] && ( |
| 208 | axisState[AXIS_STATE_NEGATIVE] || |
| 209 | axisState[AXIS_STATE_POSITIVE])) |
| 210 | stopTimer(joystick); |
| 211 | |
197 | 212 | axisState[0] = axisState[1] = false; |
198 | 213 | return false; |
199 | 214 | } |
| 215 | startTimer(joystick); |
200 | 216 | break; |
201 | 217 | } |
202 | 218 | #endif |
... | ... | |
259 | 275 | |
260 | 276 | return true; |
261 | 277 | } |
| 278 | |
| 279 | Uint32 keyRepeatCallback(Uint32 timeout __attribute__((unused)), void *d) |
| 280 | { |
| 281 | struct Joystick *joystick = (struct Joystick *) d; |
| 282 | Uint8 hatState = joystick->hatState; |
| 283 | |
| 284 | if (joystick->axisState[1][AXIS_STATE_NEGATIVE]) |
| 285 | hatState |= SDL_HAT_UP; |
| 286 | else if (joystick->axisState[1][AXIS_STATE_POSITIVE]) |
| 287 | hatState |= SDL_HAT_DOWN; |
| 288 | if (joystick->axisState[0][AXIS_STATE_NEGATIVE]) |
| 289 | hatState |= SDL_HAT_LEFT; |
| 290 | else if (joystick->axisState[0][AXIS_STATE_POSITIVE]) |
| 291 | hatState |= SDL_HAT_RIGHT; |
| 292 | |
| 293 | SDL_JoyHatEvent e = { |
| 294 | .type = SDL_JOYHATMOTION, |
| 295 | .which = (Uint8) SDL_JoystickIndex(joystick->joystick), |
| 296 | .hat = 0, |
| 297 | .value = hatState, |
| 298 | }; |
| 299 | SDL_PushEvent((SDL_Event *) &e); |
| 300 | |
| 301 | return INPUT_KEY_REPEAT_RATE; |
| 302 | } |
| 303 | |
| 304 | void InputManager::startTimer(Joystick *joystick) |
| 305 | { |
| 306 | if (joystick->timer) |
| 307 | return; |
| 308 | |
| 309 | joystick->timer = SDL_AddTimer(INPUT_KEY_REPEAT_DELAY, |
| 310 | keyRepeatCallback, joystick); |
| 311 | } |
| 312 | |
| 313 | void InputManager::stopTimer(Joystick *joystick) |
| 314 | { |
| 315 | if (joystick->timer) { |
| 316 | SDL_RemoveTimer(joystick->timer); |
| 317 | joystick->timer = nullptr; |
| 318 | } |
| 319 | } |
src/inputmanager.h |
25 | 25 | #include <string> |
26 | 26 | #include <vector> |
27 | 27 | |
| 28 | #define INPUT_KEY_REPEAT_DELAY 250 |
| 29 | #define INPUT_KEY_REPEAT_RATE 150 |
| 30 | |
28 | 31 | class Menu; |
29 | 32 | |
30 | 33 | enum EventCode { |
... | ... | |
34 | 37 | REPAINT_MENU, |
35 | 38 | }; |
36 | 39 | |
| 40 | #ifndef SDL_JOYSTICK_DISABLED |
| 41 | #define AXIS_STATE_POSITIVE 0 |
| 42 | #define AXIS_STATE_NEGATIVE 1 |
| 43 | struct Joystick { |
| 44 | SDL_Joystick *joystick; |
| 45 | bool axisState[2][2]; |
| 46 | Uint8 hatState; |
| 47 | SDL_TimerID timer; |
| 48 | }; |
| 49 | #endif |
| 50 | |
37 | 51 | class InputManager { |
38 | 52 | public: |
39 | 53 | enum Button { |
... | ... | |
66 | 80 | |
67 | 81 | ButtonMapEntry buttonMap[BUTTON_TYPE_SIZE]; |
68 | 82 | #ifndef SDL_JOYSTICK_DISABLED |
69 | | #define AXIS_STATE_POSITIVE 0 |
70 | | #define AXIS_STATE_NEGATIVE 1 |
71 | | struct Joystick { |
72 | | SDL_Joystick *joystick; |
73 | | bool axisState[2][2]; |
74 | | }; |
75 | | |
76 | 83 | std::vector<Joystick> joysticks; |
| 84 | |
| 85 | void startTimer(Joystick *joystick); |
| 86 | void stopTimer(Joystick *joystick); |
77 | 87 | #endif |
78 | 88 | }; |
79 | 89 | |