Mercurial > sdl-ios-xcode

comparison src/joystick/SDL_joystick.c @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents 97d0966f4bf7
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
38 38
39 Uint8 SDL_numjoysticks = 0; 39 Uint8 SDL_numjoysticks = 0;
40 SDL_Joystick **SDL_joysticks = NULL; 40 SDL_Joystick **SDL_joysticks = NULL;
41 static SDL_Joystick *default_joystick = NULL; 41 static SDL_Joystick *default_joystick = NULL;
42 42
43 int SDL_JoystickInit(void) 43 int
44 { 44 SDL_JoystickInit (void)
45 int arraylen; 45 {
46 int status; 46 int arraylen;
47 47 int status;
48 SDL_numjoysticks = 0; 48
49 status = SDL_SYS_JoystickInit(); 49 SDL_numjoysticks = 0;
50 if ( status >= 0 ) { 50 status = SDL_SYS_JoystickInit ();
51 arraylen = (status+1)*sizeof(*SDL_joysticks); 51 if (status >= 0) {
52 SDL_joysticks = (SDL_Joystick **)SDL_malloc(arraylen); 52 arraylen = (status + 1) * sizeof (*SDL_joysticks);
53 if ( SDL_joysticks == NULL ) { 53 SDL_joysticks = (SDL_Joystick **) SDL_malloc (arraylen);
54 SDL_numjoysticks = 0; 54 if (SDL_joysticks == NULL) {
55 } else { 55 SDL_numjoysticks = 0;
56 SDL_memset(SDL_joysticks, 0, arraylen); 56 } else {
57 SDL_numjoysticks = status; 57 SDL_memset (SDL_joysticks, 0, arraylen);
58 } 58 SDL_numjoysticks = status;
59 status = 0; 59 }
60 } 60 status = 0;
61 default_joystick = NULL; 61 }
62 return(status); 62 default_joystick = NULL;
63 return (status);
63 } 64 }
64 65
65 /* 66 /*
66 * Count the number of joysticks attached to the system 67 * Count the number of joysticks attached to the system
67 */ 68 */
68 int SDL_NumJoysticks(void) 69 int
69 { 70 SDL_NumJoysticks (void)
70 return SDL_numjoysticks; 71 {
72 return SDL_numjoysticks;
71 } 73 }
72 74
73 /* 75 /*
74 * Get the implementation dependent name of a joystick 76 * Get the implementation dependent name of a joystick
75 */ 77 */
76 const char *SDL_JoystickName(int device_index) 78 const char *
77 { 79 SDL_JoystickName (int device_index)
78 if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) { 80 {
79 SDL_SetError("There are %d joysticks available", 81 if ((device_index < 0) || (device_index >= SDL_numjoysticks)) {
80 SDL_numjoysticks); 82 SDL_SetError ("There are %d joysticks available", SDL_numjoysticks);
81 return(NULL); 83 return (NULL);
82 } 84 }
83 return(SDL_SYS_JoystickName(device_index)); 85 return (SDL_SYS_JoystickName (device_index));
84 } 86 }
85 87
86 /* 88 /*
87 * Open a joystick for use - the index passed as an argument refers to 89 * Open a joystick for use - the index passed as an argument refers to
88 * the N'th joystick on the system. This index is the value which will 90 * the N'th joystick on the system. This index is the value which will
89 * identify this joystick in future joystick events. 91 * identify this joystick in future joystick events.
90 * 92 *
91 * This function returns a joystick identifier, or NULL if an error occurred. 93 * This function returns a joystick identifier, or NULL if an error occurred.
92 */ 94 */
93 SDL_Joystick *SDL_JoystickOpen(int device_index) 95 SDL_Joystick *
94 { 96 SDL_JoystickOpen (int device_index)
95 int i; 97 {
96 SDL_Joystick *joystick; 98 int i;
97 99 SDL_Joystick *joystick;
98 if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) { 100
99 SDL_SetError("There are %d joysticks available", 101 if ((device_index < 0) || (device_index >= SDL_numjoysticks)) {
100 SDL_numjoysticks); 102 SDL_SetError ("There are %d joysticks available", SDL_numjoysticks);
101 return(NULL); 103 return (NULL);
102 } 104 }
103 105
104 /* If the joystick is already open, return it */ 106 /* If the joystick is already open, return it */
105 for ( i=0; SDL_joysticks[i]; ++i ) { 107 for (i = 0; SDL_joysticks[i]; ++i) {
106 if ( device_index == SDL_joysticks[i]->index ) { 108 if (device_index == SDL_joysticks[i]->index) {
107 joystick = SDL_joysticks[i]; 109 joystick = SDL_joysticks[i];
108 ++joystick->ref_count; 110 ++joystick->ref_count;
109 return(joystick); 111 return (joystick);
110 } 112 }
111 } 113 }
112 114
113 /* Create and initialize the joystick */ 115 /* Create and initialize the joystick */
114 joystick = (SDL_Joystick *)SDL_malloc((sizeof *joystick)); 116 joystick = (SDL_Joystick *) SDL_malloc ((sizeof *joystick));
115 if ( joystick != NULL ) { 117 if (joystick != NULL) {
116 SDL_memset(joystick, 0, (sizeof *joystick)); 118 SDL_memset (joystick, 0, (sizeof *joystick));
117 joystick->index = device_index; 119 joystick->index = device_index;
118 if ( SDL_SYS_JoystickOpen(joystick) < 0 ) { 120 if (SDL_SYS_JoystickOpen (joystick) < 0) {
119 SDL_free(joystick); 121 SDL_free (joystick);
120 joystick = NULL; 122 joystick = NULL;
121 } else { 123 } else {
122 if ( joystick->naxes > 0 ) { 124 if (joystick->naxes > 0) {
123 joystick->axes = (Sint16 *)SDL_malloc 125 joystick->axes = (Sint16 *) SDL_malloc
124 (joystick->naxes*sizeof(Sint16)); 126 (joystick->naxes * sizeof (Sint16));
125 } 127 }
126 if ( joystick->nhats > 0 ) { 128 if (joystick->nhats > 0) {
127 joystick->hats = (Uint8 *)SDL_malloc 129 joystick->hats = (Uint8 *) SDL_malloc
128 (joystick->nhats*sizeof(Uint8)); 130 (joystick->nhats * sizeof (Uint8));
129 } 131 }
130 if ( joystick->nballs > 0 ) { 132 if (joystick->nballs > 0) {
131 joystick->balls = (struct balldelta *)SDL_malloc 133 joystick->balls = (struct balldelta *) SDL_malloc
132 (joystick->nballs*sizeof(*joystick->balls)); 134 (joystick->nballs * sizeof (*joystick->balls));
133 } 135 }
134 if ( joystick->nbuttons > 0 ) { 136 if (joystick->nbuttons > 0) {
135 joystick->buttons = (Uint8 *)SDL_malloc 137 joystick->buttons = (Uint8 *) SDL_malloc
136 (joystick->nbuttons*sizeof(Uint8)); 138 (joystick->nbuttons * sizeof (Uint8));
137 } 139 }
138 if ( ((joystick->naxes > 0) && !joystick->axes) 140 if (((joystick->naxes > 0) && !joystick->axes)
139 || ((joystick->nhats > 0) && !joystick->hats) 141 || ((joystick->nhats > 0) && !joystick->hats)
140 || ((joystick->nballs > 0) && !joystick->balls) 142 || ((joystick->nballs > 0) && !joystick->balls)
141 || ((joystick->nbuttons > 0) && !joystick->buttons)) { 143 || ((joystick->nbuttons > 0) && !joystick->buttons)) {
142 SDL_OutOfMemory(); 144 SDL_OutOfMemory ();
143 SDL_JoystickClose(joystick); 145 SDL_JoystickClose (joystick);
144 joystick = NULL; 146 joystick = NULL;
145 } 147 }
146 if ( joystick->axes ) { 148 if (joystick->axes) {
147 SDL_memset(joystick->axes, 0, 149 SDL_memset (joystick->axes, 0,
148 joystick->naxes*sizeof(Sint16)); 150 joystick->naxes * sizeof (Sint16));
149 } 151 }
150 if ( joystick->hats ) { 152 if (joystick->hats) {
151 SDL_memset(joystick->hats, 0, 153 SDL_memset (joystick->hats, 0,
152 joystick->nhats*sizeof(Uint8)); 154 joystick->nhats * sizeof (Uint8));
153 } 155 }
154 if ( joystick->balls ) { 156 if (joystick->balls) {
155 SDL_memset(joystick->balls, 0, 157 SDL_memset (joystick->balls, 0,
156 joystick->nballs*sizeof(*joystick->balls)); 158 joystick->nballs * sizeof (*joystick->balls));
157 } 159 }
158 if ( joystick->buttons ) { 160 if (joystick->buttons) {
159 SDL_memset(joystick->buttons, 0, 161 SDL_memset (joystick->buttons, 0,
160 joystick->nbuttons*sizeof(Uint8)); 162 joystick->nbuttons * sizeof (Uint8));
161 } 163 }
162 } 164 }
163 } 165 }
164 if ( joystick ) { 166 if (joystick) {
165 /* Add joystick to list */ 167 /* Add joystick to list */
166 ++joystick->ref_count; 168 ++joystick->ref_count;
167 SDL_Lock_EventThread(); 169 SDL_Lock_EventThread ();
168 for ( i=0; SDL_joysticks[i]; ++i ) 170 for (i = 0; SDL_joysticks[i]; ++i)
169 /* Skip to next joystick */; 171 /* Skip to next joystick */ ;
170 SDL_joysticks[i] = joystick; 172 SDL_joysticks[i] = joystick;
171 SDL_Unlock_EventThread(); 173 SDL_Unlock_EventThread ();
172 } 174 }
173 return(joystick); 175 return (joystick);
174 } 176 }
175 177
176 /* 178 /*
177 * Returns 1 if the joystick has been opened, or 0 if it has not. 179 * Returns 1 if the joystick has been opened, or 0 if it has not.
178 */ 180 */
179 int SDL_JoystickOpened(int device_index) 181 int
180 { 182 SDL_JoystickOpened (int device_index)
181 int i, opened; 183 {
182 184 int i, opened;
183 opened = 0; 185
184 for ( i=0; SDL_joysticks[i]; ++i ) { 186 opened = 0;
185 if ( SDL_joysticks[i]->index == (Uint8)device_index ) { 187 for (i = 0; SDL_joysticks[i]; ++i) {
186 opened = 1; 188 if (SDL_joysticks[i]->index == (Uint8) device_index) {
187 break; 189 opened = 1;
188 } 190 break;
189 } 191 }
190 return(opened); 192 }
191 } 193 return (opened);
192 194 }
193 static int ValidJoystick(SDL_Joystick **joystick) 195
194 { 196 static int
195 int valid; 197 ValidJoystick (SDL_Joystick ** joystick)
196 198 {
197 if ( *joystick == NULL ) { 199 int valid;
198 *joystick = default_joystick; 200
199 } 201 if (*joystick == NULL) {
200 if ( *joystick == NULL ) { 202 *joystick = default_joystick;
201 SDL_SetError("Joystick hasn't been opened yet"); 203 }
202 valid = 0; 204 if (*joystick == NULL) {
203 } else { 205 SDL_SetError ("Joystick hasn't been opened yet");
204 valid = 1; 206 valid = 0;
205 } 207 } else {
206 return valid; 208 valid = 1;
209 }
210 return valid;
207 } 211 }
208 212
209 /* 213 /*
210 * Get the device index of an opened joystick. 214 * Get the device index of an opened joystick.
211 */ 215 */
212 int SDL_JoystickIndex(SDL_Joystick *joystick) 216 int
213 { 217 SDL_JoystickIndex (SDL_Joystick * joystick)
214 if ( ! ValidJoystick(&joystick) ) { 218 {
215 return(-1); 219 if (!ValidJoystick (&joystick)) {
216 } 220 return (-1);
217 return(joystick->index); 221 }
222 return (joystick->index);
218 } 223 }
219 224
220 /* 225 /*
221 * Get the number of multi-dimensional axis controls on a joystick 226 * Get the number of multi-dimensional axis controls on a joystick
222 */ 227 */
223 int SDL_JoystickNumAxes(SDL_Joystick *joystick) 228 int
224 { 229 SDL_JoystickNumAxes (SDL_Joystick * joystick)
225 if ( ! ValidJoystick(&joystick) ) { 230 {
226 return(-1); 231 if (!ValidJoystick (&joystick)) {
227 } 232 return (-1);
228 return(joystick->naxes); 233 }
234 return (joystick->naxes);
229 } 235 }
230 236
231 /* 237 /*
232 * Get the number of hats on a joystick 238 * Get the number of hats on a joystick
233 */ 239 */
234 int SDL_JoystickNumHats(SDL_Joystick *joystick) 240 int
235 { 241 SDL_JoystickNumHats (SDL_Joystick * joystick)
236 if ( ! ValidJoystick(&joystick) ) { 242 {
237 return(-1); 243 if (!ValidJoystick (&joystick)) {
238 } 244 return (-1);
239 return(joystick->nhats); 245 }
246 return (joystick->nhats);
240 } 247 }
241 248
242 /* 249 /*
243 * Get the number of trackballs on a joystick 250 * Get the number of trackballs on a joystick
244 */ 251 */
245 int SDL_JoystickNumBalls(SDL_Joystick *joystick) 252 int
246 { 253 SDL_JoystickNumBalls (SDL_Joystick * joystick)
247 if ( ! ValidJoystick(&joystick) ) { 254 {
248 return(-1); 255 if (!ValidJoystick (&joystick)) {
249 } 256 return (-1);
250 return(joystick->nballs); 257 }
258 return (joystick->nballs);
251 } 259 }
252 260
253 /* 261 /*
254 * Get the number of buttons on a joystick 262 * Get the number of buttons on a joystick
255 */ 263 */
256 int SDL_JoystickNumButtons(SDL_Joystick *joystick) 264 int
257 { 265 SDL_JoystickNumButtons (SDL_Joystick * joystick)
258 if ( ! ValidJoystick(&joystick) ) { 266 {
259 return(-1); 267 if (!ValidJoystick (&joystick)) {
260 } 268 return (-1);
261 return(joystick->nbuttons); 269 }
270 return (joystick->nbuttons);
262 } 271 }
263 272
264 /* 273 /*
265 * Get the current state of an axis control on a joystick 274 * Get the current state of an axis control on a joystick
266 */ 275 */
267 Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis) 276 Sint16
268 { 277 SDL_JoystickGetAxis (SDL_Joystick * joystick, int axis)
269 Sint16 state; 278 {
270 279 Sint16 state;
271 if ( ! ValidJoystick(&joystick) ) { 280
272 return(0); 281 if (!ValidJoystick (&joystick)) {
273 } 282 return (0);
274 if ( axis < joystick->naxes ) { 283 }
275 state = joystick->axes[axis]; 284 if (axis < joystick->naxes) {
276 } else { 285 state = joystick->axes[axis];
277 SDL_SetError("Joystick only has %d axes", joystick->naxes); 286 } else {
278 state = 0; 287 SDL_SetError ("Joystick only has %d axes", joystick->naxes);
279 } 288 state = 0;
280 return(state); 289 }
290 return (state);
281 } 291 }
282 292
283 /* 293 /*
284 * Get the current state of a hat on a joystick 294 * Get the current state of a hat on a joystick
285 */ 295 */
286 Uint8 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat) 296 Uint8
287 { 297 SDL_JoystickGetHat (SDL_Joystick * joystick, int hat)
288 Uint8 state; 298 {
289 299 Uint8 state;
290 if ( ! ValidJoystick(&joystick) ) { 300
291 return(0); 301 if (!ValidJoystick (&joystick)) {
292 } 302 return (0);
293 if ( hat < joystick->nhats ) { 303 }
294 state = joystick->hats[hat]; 304 if (hat < joystick->nhats) {
295 } else { 305 state = joystick->hats[hat];
296 SDL_SetError("Joystick only has %d hats", joystick->nhats); 306 } else {
297 state = 0; 307 SDL_SetError ("Joystick only has %d hats", joystick->nhats);
298 } 308 state = 0;
299 return(state); 309 }
310 return (state);
300 } 311 }
301 312
302 /* 313 /*
303 * Get the ball axis change since the last poll 314 * Get the ball axis change since the last poll
304 */ 315 */
305 int SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy) 316 int
306 { 317 SDL_JoystickGetBall (SDL_Joystick * joystick, int ball, int *dx, int *dy)
307 int retval; 318 {
308 319 int retval;
309 if ( ! ValidJoystick(&joystick) ) { 320
310 return(-1); 321 if (!ValidJoystick (&joystick)) {
311 } 322 return (-1);
312 323 }
313 retval = 0; 324
314 if ( ball < joystick->nballs ) { 325 retval = 0;
315 if ( dx ) { 326 if (ball < joystick->nballs) {
316 *dx = joystick->balls[ball].dx; 327 if (dx) {
317 } 328 *dx = joystick->balls[ball].dx;
318 if ( dy ) { 329 }
319 *dy = joystick->balls[ball].dy; 330 if (dy) {
320 } 331 *dy = joystick->balls[ball].dy;
321 joystick->balls[ball].dx = 0; 332 }
322 joystick->balls[ball].dy = 0; 333 joystick->balls[ball].dx = 0;
323 } else { 334 joystick->balls[ball].dy = 0;
324 SDL_SetError("Joystick only has %d balls", joystick->nballs); 335 } else {
325 retval = -1; 336 SDL_SetError ("Joystick only has %d balls", joystick->nballs);
326 } 337 retval = -1;
327 return(retval); 338 }
339 return (retval);
328 } 340 }
329 341
330 /* 342 /*
331 * Get the current state of a button on a joystick 343 * Get the current state of a button on a joystick
332 */ 344 */
333 Uint8 SDL_JoystickGetButton(SDL_Joystick *joystick, int button) 345 Uint8
334 { 346 SDL_JoystickGetButton (SDL_Joystick * joystick, int button)
335 Uint8 state; 347 {
336 348 Uint8 state;
337 if ( ! ValidJoystick(&joystick) ) { 349
338 return(0); 350 if (!ValidJoystick (&joystick)) {
339 } 351 return (0);
340 if ( button < joystick->nbuttons ) { 352 }
341 state = joystick->buttons[button]; 353 if (button < joystick->nbuttons) {
342 } else { 354 state = joystick->buttons[button];
343 SDL_SetError("Joystick only has %d buttons",joystick->nbuttons); 355 } else {
344 state = 0; 356 SDL_SetError ("Joystick only has %d buttons", joystick->nbuttons);
345 } 357 state = 0;
346 return(state); 358 }
359 return (state);
347 } 360 }
348 361
349 /* 362 /*
350 * Close a joystick previously opened with SDL_JoystickOpen() 363 * Close a joystick previously opened with SDL_JoystickOpen()
351 */ 364 */
352 void SDL_JoystickClose(SDL_Joystick *joystick) 365 void
353 { 366 SDL_JoystickClose (SDL_Joystick * joystick)
354 int i; 367 {
355 368 int i;
356 if ( ! ValidJoystick(&joystick) ) { 369
357 return; 370 if (!ValidJoystick (&joystick)) {
358 } 371 return;
359 372 }
360 /* First decrement ref count */ 373
361 if ( --joystick->ref_count > 0 ) { 374 /* First decrement ref count */
362 return; 375 if (--joystick->ref_count > 0) {
363 } 376 return;
364 377 }
365 /* Lock the event queue - prevent joystick polling */ 378
366 SDL_Lock_EventThread(); 379 /* Lock the event queue - prevent joystick polling */
367 380 SDL_Lock_EventThread ();
368 if ( joystick == default_joystick ) { 381
369 default_joystick = NULL; 382 if (joystick == default_joystick) {
370 } 383 default_joystick = NULL;
371 SDL_SYS_JoystickClose(joystick); 384 }
372 385 SDL_SYS_JoystickClose (joystick);
373 /* Remove joystick from list */ 386
374 for ( i=0; SDL_joysticks[i]; ++i ) { 387 /* Remove joystick from list */
375 if ( joystick == SDL_joysticks[i] ) { 388 for (i = 0; SDL_joysticks[i]; ++i) {
376 SDL_memcpy(&SDL_joysticks[i], &SDL_joysticks[i+1], 389 if (joystick == SDL_joysticks[i]) {
377 (SDL_numjoysticks-i)*sizeof(joystick)); 390 SDL_memcpy (&SDL_joysticks[i], &SDL_joysticks[i + 1],
378 break; 391 (SDL_numjoysticks - i) * sizeof (joystick));
379 } 392 break;
380 } 393 }
381 394 }
382 /* Let the event thread keep running */ 395
383 SDL_Unlock_EventThread(); 396 /* Let the event thread keep running */
384 397 SDL_Unlock_EventThread ();
385 /* Free the data associated with this joystick */ 398
386 if ( joystick->axes ) { 399 /* Free the data associated with this joystick */
387 SDL_free(joystick->axes); 400 if (joystick->axes) {
388 } 401 SDL_free (joystick->axes);
389 if ( joystick->hats ) { 402 }
390 SDL_free(joystick->hats); 403 if (joystick->hats) {
391 } 404 SDL_free (joystick->hats);
392 if ( joystick->balls ) { 405 }
393 SDL_free(joystick->balls); 406 if (joystick->balls) {
394 } 407 SDL_free (joystick->balls);
395 if ( joystick->buttons ) { 408 }
396 SDL_free(joystick->buttons); 409 if (joystick->buttons) {
397 } 410 SDL_free (joystick->buttons);
398 SDL_free(joystick); 411 }
399 } 412 SDL_free (joystick);
400 413 }
401 void SDL_JoystickQuit(void) 414
402 { 415 void
403 /* Stop the event polling */ 416 SDL_JoystickQuit (void)
404 SDL_Lock_EventThread(); 417 {
405 SDL_numjoysticks = 0; 418 /* Stop the event polling */
406 SDL_Unlock_EventThread(); 419 SDL_Lock_EventThread ();
407 420 SDL_numjoysticks = 0;
408 /* Quit the joystick setup */ 421 SDL_Unlock_EventThread ();
409 SDL_SYS_JoystickQuit(); 422
410 if ( SDL_joysticks ) { 423 /* Quit the joystick setup */
411 SDL_free(SDL_joysticks); 424 SDL_SYS_JoystickQuit ();
412 SDL_joysticks = NULL; 425 if (SDL_joysticks) {
413 } 426 SDL_free (SDL_joysticks);
427 SDL_joysticks = NULL;
428 }
414 } 429 }
415 430
416 431
417 /* These are global for SDL_sysjoystick.c and SDL_events.c */ 432 /* These are global for SDL_sysjoystick.c and SDL_events.c */
418 433
419 int SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value) 434 int
420 { 435 SDL_PrivateJoystickAxis (SDL_Joystick * joystick, Uint8 axis, Sint16 value)
421 int posted; 436 {
422 437 int posted;
423 /* Update internal joystick state */ 438
424 joystick->axes[axis] = value; 439 /* Update internal joystick state */
425 440 joystick->axes[axis] = value;
426 /* Post the event, if desired */ 441
427 posted = 0; 442 /* Post the event, if desired */
443 posted = 0;
428 #if !SDL_EVENTS_DISABLED 444 #if !SDL_EVENTS_DISABLED
429 if ( SDL_ProcessEvents[SDL_JOYAXISMOTION] == SDL_ENABLE ) { 445 if (SDL_ProcessEvents[SDL_JOYAXISMOTION] == SDL_ENABLE) {
430 SDL_Event event; 446 SDL_Event event;
431 event.type = SDL_JOYAXISMOTION; 447 event.type = SDL_JOYAXISMOTION;
432 event.jaxis.which = joystick->index; 448 event.jaxis.which = joystick->index;
433 event.jaxis.axis = axis; 449 event.jaxis.axis = axis;
434 event.jaxis.value = value; 450 event.jaxis.value = value;
435 if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) { 451 if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) {
436 posted = 1; 452 posted = 1;
437 SDL_PushEvent(&event); 453 SDL_PushEvent (&event);
438 } 454 }
439 } 455 }
440 #endif /* !SDL_EVENTS_DISABLED */ 456 #endif /* !SDL_EVENTS_DISABLED */
441 return(posted); 457 return (posted);
442 } 458 }
443 459
444 int SDL_PrivateJoystickHat(SDL_Joystick *joystick, Uint8 hat, Uint8 value) 460 int
445 { 461 SDL_PrivateJoystickHat (SDL_Joystick * joystick, Uint8 hat, Uint8 value)
446 int posted; 462 {
447 463 int posted;
448 /* Update internal joystick state */ 464
449 joystick->hats[hat] = value; 465 /* Update internal joystick state */
450 466 joystick->hats[hat] = value;
451 /* Post the event, if desired */ 467
452 posted = 0; 468 /* Post the event, if desired */
469 posted = 0;
453 #if !SDL_EVENTS_DISABLED 470 #if !SDL_EVENTS_DISABLED
454 if ( SDL_ProcessEvents[SDL_JOYHATMOTION] == SDL_ENABLE ) { 471 if (SDL_ProcessEvents[SDL_JOYHATMOTION] == SDL_ENABLE) {
455 SDL_Event event; 472 SDL_Event event;
456 event.jhat.type = SDL_JOYHATMOTION; 473 event.jhat.type = SDL_JOYHATMOTION;
457 event.jhat.which = joystick->index; 474 event.jhat.which = joystick->index;
458 event.jhat.hat = hat; 475 event.jhat.hat = hat;
459 event.jhat.value = value; 476 event.jhat.value = value;
460 if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) { 477 if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) {
461 posted = 1; 478 posted = 1;
462 SDL_PushEvent(&event); 479 SDL_PushEvent (&event);
463 } 480 }
464 } 481 }
465 #endif /* !SDL_EVENTS_DISABLED */ 482 #endif /* !SDL_EVENTS_DISABLED */
466 return(posted); 483 return (posted);
467 } 484 }
468 485
469 int SDL_PrivateJoystickBall(SDL_Joystick *joystick, Uint8 ball, 486 int
470 Sint16 xrel, Sint16 yrel) 487 SDL_PrivateJoystickBall (SDL_Joystick * joystick, Uint8 ball,
471 { 488 Sint16 xrel, Sint16 yrel)
472 int posted; 489 {
473 490 int posted;
474 /* Update internal mouse state */ 491
475 joystick->balls[ball].dx += xrel; 492 /* Update internal mouse state */
476 joystick->balls[ball].dy += yrel; 493 joystick->balls[ball].dx += xrel;
477 494 joystick->balls[ball].dy += yrel;
478 /* Post the event, if desired */ 495
479 posted = 0; 496 /* Post the event, if desired */
497 posted = 0;
480 #if !SDL_EVENTS_DISABLED 498 #if !SDL_EVENTS_DISABLED
481 if ( SDL_ProcessEvents[SDL_JOYBALLMOTION] == SDL_ENABLE ) { 499 if (SDL_ProcessEvents[SDL_JOYBALLMOTION] == SDL_ENABLE) {
482 SDL_Event event; 500 SDL_Event event;
483 event.jball.type = SDL_JOYBALLMOTION; 501 event.jball.type = SDL_JOYBALLMOTION;
484 event.jball.which = joystick->index; 502 event.jball.which = joystick->index;
485 event.jball.ball = ball; 503 event.jball.ball = ball;
486 event.jball.xrel = xrel; 504 event.jball.xrel = xrel;
487 event.jball.yrel = yrel; 505 event.jball.yrel = yrel;
488 if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) { 506 if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) {
489 posted = 1; 507 posted = 1;
490 SDL_PushEvent(&event); 508 SDL_PushEvent (&event);
491 } 509 }
492 } 510 }
493 #endif /* !SDL_EVENTS_DISABLED */ 511 #endif /* !SDL_EVENTS_DISABLED */
494 return(posted); 512 return (posted);
495 } 513 }
496 514
497 int SDL_PrivateJoystickButton(SDL_Joystick *joystick, Uint8 button, Uint8 state) 515 int
498 { 516 SDL_PrivateJoystickButton (SDL_Joystick * joystick, Uint8 button, Uint8 state)
499 int posted; 517 {
518 int posted;
500 #if !SDL_EVENTS_DISABLED 519 #if !SDL_EVENTS_DISABLED
501 SDL_Event event; 520 SDL_Event event;
502 521
503 switch ( state ) { 522 switch (state) {
504 case SDL_PRESSED: 523 case SDL_PRESSED:
505 event.type = SDL_JOYBUTTONDOWN; 524 event.type = SDL_JOYBUTTONDOWN;
506 break; 525 break;
507 case SDL_RELEASED: 526 case SDL_RELEASED:
508 event.type = SDL_JOYBUTTONUP; 527 event.type = SDL_JOYBUTTONUP;
509 break; 528 break;
510 default: 529 default:
511 /* Invalid state -- bail */ 530 /* Invalid state -- bail */
512 return(0); 531 return (0);
513 } 532 }
514 #endif /* !SDL_EVENTS_DISABLED */ 533 #endif /* !SDL_EVENTS_DISABLED */
515 534
516 /* Update internal joystick state */ 535 /* Update internal joystick state */
517 joystick->buttons[button] = state; 536 joystick->buttons[button] = state;
518 537
519 /* Post the event, if desired */ 538 /* Post the event, if desired */
520 posted = 0; 539 posted = 0;
521 #if !SDL_EVENTS_DISABLED 540 #if !SDL_EVENTS_DISABLED
522 if ( SDL_ProcessEvents[event.type] == SDL_ENABLE ) { 541 if (SDL_ProcessEvents[event.type] == SDL_ENABLE) {
523 event.jbutton.which = joystick->index; 542 event.jbutton.which = joystick->index;
524 event.jbutton.button = button; 543 event.jbutton.button = button;
525 event.jbutton.state = state; 544 event.jbutton.state = state;
526 if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) { 545 if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) {
527 posted = 1; 546 posted = 1;
528 SDL_PushEvent(&event); 547 SDL_PushEvent (&event);
529 } 548 }
530 } 549 }
531 #endif /* !SDL_EVENTS_DISABLED */ 550 #endif /* !SDL_EVENTS_DISABLED */
532 return(posted); 551 return (posted);
533 } 552 }
534 553
535 void SDL_JoystickUpdate(void) 554 void
536 { 555 SDL_JoystickUpdate (void)
537 int i; 556 {
538 557 int i;
539 for ( i=0; SDL_joysticks[i]; ++i ) { 558
540 SDL_SYS_JoystickUpdate(SDL_joysticks[i]); 559 for (i = 0; SDL_joysticks[i]; ++i) {
541 } 560 SDL_SYS_JoystickUpdate (SDL_joysticks[i]);
542 } 561 }
543 562 }
544 int SDL_JoystickEventState(int state) 563
564 int
565 SDL_JoystickEventState (int state)
545 { 566 {
546 #if SDL_EVENTS_DISABLED 567 #if SDL_EVENTS_DISABLED
547 return SDL_IGNORE; 568 return SDL_IGNORE;
548 #else 569 #else
549 const Uint8 event_list[] = { 570 const Uint8 event_list[] = {
550 SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, 571 SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION,
551 SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, 572 SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP,
552 }; 573 };
553 unsigned int i; 574 unsigned int i;
554 575
555 switch (state) { 576 switch (state) {
556 case SDL_QUERY: 577 case SDL_QUERY:
557 state = SDL_IGNORE; 578 state = SDL_IGNORE;
558 for ( i=0; i<SDL_arraysize(event_list); ++i ) { 579 for (i = 0; i < SDL_arraysize (event_list); ++i) {
559 state = SDL_EventState(event_list[i],SDL_QUERY); 580 state = SDL_EventState (event_list[i], SDL_QUERY);
560 if ( state == SDL_ENABLE ) { 581 if (state == SDL_ENABLE) {
561 break; 582 break;
562 } 583 }
563 } 584 }
564 break; 585 break;
565 default: 586 default:
566 for ( i=0; i<SDL_arraysize(event_list); ++i ) { 587 for (i = 0; i < SDL_arraysize (event_list); ++i) {
567 SDL_EventState(event_list[i], state); 588 SDL_EventState (event_list[i], state);
568 } 589 }
569 break; 590 break;
570 } 591 }
571 return(state); 592 return (state);
572 #endif /* SDL_EVENTS_DISABLED */ 593 #endif /* SDL_EVENTS_DISABLED */
573 } 594 }
595
596 /* vi: set ts=4 sw=4 expandtab: */