Home | History | Annotate | Download | only in joystick 
      1 /*
      2     SDL - Simple DirectMedia Layer
      3     Copyright (C) 1997-2006 Sam Lantinga
      4 
      5     This library is free software; you can redistribute it and/or
      6     modify it under the terms of the GNU Lesser General Public
      7     License as published by the Free Software Foundation; either
      8     version 2.1 of the License, or (at your option) any later version.
      9 
     10     This library is distributed in the hope that it will be useful,
     11     but WITHOUT ANY WARRANTY; without even the implied warranty of
     12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13     Lesser General Public License for more details.
     14 
     15     You should have received a copy of the GNU Lesser General Public
     16     License along with this library; if not, write to the Free Software
     17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
     18 
     19     Sam Lantinga
     20     slouken (at) libsdl.org
     21 */
     22 #include "SDL_config.h"
     23 
     24 /* This is the joystick API for Simple DirectMedia Layer */
     25 
     26 #include "SDL_events.h"
     27 #include "SDL_sysjoystick.h"
     28 #include "SDL_joystick_c.h"
     29 #if !SDL_EVENTS_DISABLED
     30 #include "../events/SDL_events_c.h"
     31 #endif
     32 
     33 /* This is used for Quake III Arena */
     34 #if SDL_EVENTS_DISABLED
     35 #define SDL_Lock_EventThread()
     36 #define SDL_Unlock_EventThread()
     37 #endif
     38 
     39 Uint8 SDL_numjoysticks = 0;
     40 SDL_Joystick **SDL_joysticks = NULL;
     41 static SDL_Joystick *default_joystick = NULL;
     42 
     43 int SDL_JoystickInit(void)
     44 {
     45 	int arraylen;
     46 	int status;
     47 
     48 	SDL_numjoysticks = 0;
     49 	status = SDL_SYS_JoystickInit();
     50 	if ( status >= 0 ) {
     51 		arraylen = (status+1)*sizeof(*SDL_joysticks);
     52 		SDL_joysticks = (SDL_Joystick **)SDL_malloc(arraylen);
     53 		if ( SDL_joysticks == NULL ) {
     54 			SDL_numjoysticks = 0;
     55 		} else {
     56 			SDL_memset(SDL_joysticks, 0, arraylen);
     57 			SDL_numjoysticks = status;
     58 		}
     59 		status = 0;
     60 	}
     61 	default_joystick = NULL;
     62 	return(status);
     63 }
     64 
     65 /*
     66  * Count the number of joysticks attached to the system
     67  */
     68 int SDL_NumJoysticks(void)
     69 {
     70 	return SDL_numjoysticks;
     71 }
     72 
     73 /*
     74  * Get the implementation dependent name of a joystick
     75  */
     76 const char *SDL_JoystickName(int device_index)
     77 {
     78 	if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) {
     79 		SDL_SetError("There are %d joysticks available",
     80 		             SDL_numjoysticks);
     81 		return(NULL);
     82 	}
     83 	return(SDL_SYS_JoystickName(device_index));
     84 }
     85 
     86 /*
     87  * 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
     89  * identify this joystick in future joystick events.
     90  *
     91  * This function returns a joystick identifier, or NULL if an error occurred.
     92  */
     93 SDL_Joystick *SDL_JoystickOpen(int device_index)
     94 {
     95 	int i;
     96 	SDL_Joystick *joystick;
     97 
     98 	if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) {
     99 		SDL_SetError("There are %d joysticks available",
    100 		             SDL_numjoysticks);
    101 		return(NULL);
    102 	}
    103 
    104 	/* If the joystick is already open, return it */
    105 	for ( i=0; SDL_joysticks[i]; ++i ) {
    106 		if ( device_index == SDL_joysticks[i]->index ) {
    107 			joystick = SDL_joysticks[i];
    108 			++joystick->ref_count;
    109 			return(joystick);
    110 		}
    111 	}
    112 
    113 	/* Create and initialize the joystick */
    114 	joystick = (SDL_Joystick *)SDL_malloc((sizeof *joystick));
    115 	if ( joystick != NULL ) {
    116 		SDL_memset(joystick, 0, (sizeof *joystick));
    117 		joystick->index = device_index;
    118 		if ( SDL_SYS_JoystickOpen(joystick) < 0 ) {
    119 			SDL_free(joystick);
    120 			joystick = NULL;
    121 		} else {
    122 			if ( joystick->naxes > 0 ) {
    123 				joystick->axes = (Sint16 *)SDL_malloc
    124 					(joystick->naxes*sizeof(Sint16));
    125 			}
    126 			if ( joystick->nhats > 0 ) {
    127 				joystick->hats = (Uint8 *)SDL_malloc
    128 					(joystick->nhats*sizeof(Uint8));
    129 			}
    130 			if ( joystick->nballs > 0 ) {
    131 				joystick->balls = (struct balldelta *)SDL_malloc
    132 				  (joystick->nballs*sizeof(*joystick->balls));
    133 			}
    134 			if ( joystick->nbuttons > 0 ) {
    135 				joystick->buttons = (Uint8 *)SDL_malloc
    136 					(joystick->nbuttons*sizeof(Uint8));
    137 			}
    138 			if ( ((joystick->naxes > 0) && !joystick->axes)
    139 			  || ((joystick->nhats > 0) && !joystick->hats)
    140 			  || ((joystick->nballs > 0) && !joystick->balls)
    141 			  || ((joystick->nbuttons > 0) && !joystick->buttons)) {
    142 				SDL_OutOfMemory();
    143 				SDL_JoystickClose(joystick);
    144 				joystick = NULL;
    145 			}
    146 			if ( joystick->axes ) {
    147 				SDL_memset(joystick->axes, 0,
    148 					joystick->naxes*sizeof(Sint16));
    149 			}
    150 			if ( joystick->hats ) {
    151 				SDL_memset(joystick->hats, 0,
    152 					joystick->nhats*sizeof(Uint8));
    153 			}
    154 			if ( joystick->balls ) {
    155 				SDL_memset(joystick->balls, 0,
    156 				  joystick->nballs*sizeof(*joystick->balls));
    157 			}
    158 			if ( joystick->buttons ) {
    159 				SDL_memset(joystick->buttons, 0,
    160 					joystick->nbuttons*sizeof(Uint8));
    161 			}
    162 		}
    163 	}
    164 	if ( joystick ) {
    165 		/* Add joystick to list */
    166 		++joystick->ref_count;
    167 		SDL_Lock_EventThread();
    168 		for ( i=0; SDL_joysticks[i]; ++i )
    169 			/* Skip to next joystick */;
    170 		SDL_joysticks[i] = joystick;
    171 		SDL_Unlock_EventThread();
    172 	}
    173 	return(joystick);
    174 }
    175 
    176 /*
    177  * Returns 1 if the joystick has been opened, or 0 if it has not.
    178  */
    179 int SDL_JoystickOpened(int device_index)
    180 {
    181 	int i, opened;
    182 
    183 	opened = 0;
    184 	for ( i=0; SDL_joysticks[i]; ++i ) {
    185 		if ( SDL_joysticks[i]->index == (Uint8)device_index ) {
    186 			opened = 1;
    187 			break;
    188 		}
    189 	}
    190 	return(opened);
    191 }
    192 
    193 static int ValidJoystick(SDL_Joystick **joystick)
    194 {
    195 	int valid;
    196 
    197 	if ( *joystick == NULL ) {
    198 		*joystick = default_joystick;
    199 	}
    200 	if ( *joystick == NULL ) {
    201 		SDL_SetError("Joystick hasn't been opened yet");
    202 		valid = 0;
    203 	} else {
    204 		valid = 1;
    205 	}
    206 	return valid;
    207 }
    208 
    209 /*
    210  * Get the device index of an opened joystick.
    211  */
    212 int SDL_JoystickIndex(SDL_Joystick *joystick)
    213 {
    214 	if ( ! ValidJoystick(&joystick) ) {
    215 		return(-1);
    216 	}
    217 	return(joystick->index);
    218 }
    219 
    220 /*
    221  * Get the number of multi-dimensional axis controls on a joystick
    222  */
    223 int SDL_JoystickNumAxes(SDL_Joystick *joystick)
    224 {
    225 	if ( ! ValidJoystick(&joystick) ) {
    226 		return(-1);
    227 	}
    228 	return(joystick->naxes);
    229 }
    230 
    231 /*
    232  * Get the number of hats on a joystick
    233  */
    234 int SDL_JoystickNumHats(SDL_Joystick *joystick)
    235 {
    236 	if ( ! ValidJoystick(&joystick) ) {
    237 		return(-1);
    238 	}
    239 	return(joystick->nhats);
    240 }
    241 
    242 /*
    243  * Get the number of trackballs on a joystick
    244  */
    245 int SDL_JoystickNumBalls(SDL_Joystick *joystick)
    246 {
    247 	if ( ! ValidJoystick(&joystick) ) {
    248 		return(-1);
    249 	}
    250 	return(joystick->nballs);
    251 }
    252 
    253 /*
    254  * Get the number of buttons on a joystick
    255  */
    256 int SDL_JoystickNumButtons(SDL_Joystick *joystick)
    257 {
    258 	if ( ! ValidJoystick(&joystick) ) {
    259 		return(-1);
    260 	}
    261 	return(joystick->nbuttons);
    262 }
    263 
    264 /*
    265  * Get the current state of an axis control on a joystick
    266  */
    267 Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis)
    268 {
    269 	Sint16 state;
    270 
    271 	if ( ! ValidJoystick(&joystick) ) {
    272 		return(0);
    273 	}
    274 	if ( axis < joystick->naxes ) {
    275 		state = joystick->axes[axis];
    276 	} else {
    277 		SDL_SetError("Joystick only has %d axes", joystick->naxes);
    278 		state = 0;
    279 	}
    280 	return(state);
    281 }
    282 
    283 /*
    284  * Get the current state of a hat on a joystick
    285  */
    286 Uint8 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat)
    287 {
    288 	Uint8 state;
    289 
    290 	if ( ! ValidJoystick(&joystick) ) {
    291 		return(0);
    292 	}
    293 	if ( hat < joystick->nhats ) {
    294 		state = joystick->hats[hat];
    295 	} else {
    296 		SDL_SetError("Joystick only has %d hats", joystick->nhats);
    297 		state = 0;
    298 	}
    299 	return(state);
    300 }
    301 
    302 /*
    303  * Get the ball axis change since the last poll
    304  */
    305 int SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy)
    306 {
    307 	int retval;
    308 
    309 	if ( ! ValidJoystick(&joystick) ) {
    310 		return(-1);
    311 	}
    312 
    313 	retval = 0;
    314 	if ( ball < joystick->nballs ) {
    315 		if ( dx ) {
    316 			*dx = joystick->balls[ball].dx;
    317 		}
    318 		if ( dy ) {
    319 			*dy = joystick->balls[ball].dy;
    320 		}
    321 		joystick->balls[ball].dx = 0;
    322 		joystick->balls[ball].dy = 0;
    323 	} else {
    324 		SDL_SetError("Joystick only has %d balls", joystick->nballs);
    325 		retval = -1;
    326 	}
    327 	return(retval);
    328 }
    329 
    330 /*
    331  * Get the current state of a button on a joystick
    332  */
    333 Uint8 SDL_JoystickGetButton(SDL_Joystick *joystick, int button)
    334 {
    335 	Uint8 state;
    336 
    337 	if ( ! ValidJoystick(&joystick) ) {
    338 		return(0);
    339 	}
    340 	if ( button < joystick->nbuttons ) {
    341 		state = joystick->buttons[button];
    342 	} else {
    343 		SDL_SetError("Joystick only has %d buttons",joystick->nbuttons);
    344 		state = 0;
    345 	}
    346 	return(state);
    347 }
    348 
    349 /*
    350  * Close a joystick previously opened with SDL_JoystickOpen()
    351  */
    352 void SDL_JoystickClose(SDL_Joystick *joystick)
    353 {
    354 	int i;
    355 
    356 	if ( ! ValidJoystick(&joystick) ) {
    357 		return;
    358 	}
    359 
    360 	/* First decrement ref count */
    361 	if ( --joystick->ref_count > 0 ) {
    362 		return;
    363 	}
    364 
    365 	/* Lock the event queue - prevent joystick polling */
    366 	SDL_Lock_EventThread();
    367 
    368 	if ( joystick == default_joystick ) {
    369 		default_joystick = NULL;
    370 	}
    371 	SDL_SYS_JoystickClose(joystick);
    372 
    373 	/* Remove joystick from list */
    374 	for ( i=0; SDL_joysticks[i]; ++i ) {
    375 		if ( joystick == SDL_joysticks[i] ) {
    376 			SDL_memcpy(&SDL_joysticks[i], &SDL_joysticks[i+1],
    377 			       (SDL_numjoysticks-i)*sizeof(joystick));
    378 			break;
    379 		}
    380 	}
    381 
    382 	/* Let the event thread keep running */
    383 	SDL_Unlock_EventThread();
    384 
    385 	/* Free the data associated with this joystick */
    386 	if ( joystick->axes ) {
    387 		SDL_free(joystick->axes);
    388 	}
    389 	if ( joystick->hats ) {
    390 		SDL_free(joystick->hats);
    391 	}
    392 	if ( joystick->balls ) {
    393 		SDL_free(joystick->balls);
    394 	}
    395 	if ( joystick->buttons ) {
    396 		SDL_free(joystick->buttons);
    397 	}
    398 	SDL_free(joystick);
    399 }
    400 
    401 void SDL_JoystickQuit(void)
    402 {
    403 	/* Stop the event polling */
    404 	SDL_Lock_EventThread();
    405 	SDL_numjoysticks = 0;
    406 	SDL_Unlock_EventThread();
    407 
    408 	/* Quit the joystick setup */
    409 	SDL_SYS_JoystickQuit();
    410 	if ( SDL_joysticks ) {
    411 		SDL_free(SDL_joysticks);
    412 		SDL_joysticks = NULL;
    413 	}
    414 }
    415 
    416 
    417 /* These are global for SDL_sysjoystick.c and SDL_events.c */
    418 
    419 int SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value)
    420 {
    421 	int posted;
    422 
    423 	/* Update internal joystick state */
    424 	joystick->axes[axis] = value;
    425 
    426 	/* Post the event, if desired */
    427 	posted = 0;
    428 #if !SDL_EVENTS_DISABLED
    429 	if ( SDL_ProcessEvents[SDL_JOYAXISMOTION] == SDL_ENABLE ) {
    430 		SDL_Event event;
    431 		event.type = SDL_JOYAXISMOTION;
    432 		event.jaxis.which = joystick->index;
    433 		event.jaxis.axis = axis;
    434 		event.jaxis.value = value;
    435 		if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) {
    436 			posted = 1;
    437 			SDL_PushEvent(&event);
    438 		}
    439 	}
    440 #endif /* !SDL_EVENTS_DISABLED */
    441 	return(posted);
    442 }
    443 
    444 int SDL_PrivateJoystickHat(SDL_Joystick *joystick, Uint8 hat, Uint8 value)
    445 {
    446 	int posted;
    447 
    448 	/* Update internal joystick state */
    449 	joystick->hats[hat] = value;
    450 
    451 	/* Post the event, if desired */
    452 	posted = 0;
    453 #if !SDL_EVENTS_DISABLED
    454 	if ( SDL_ProcessEvents[SDL_JOYHATMOTION] == SDL_ENABLE ) {
    455 		SDL_Event event;
    456 		event.jhat.type = SDL_JOYHATMOTION;
    457 		event.jhat.which = joystick->index;
    458 		event.jhat.hat = hat;
    459 		event.jhat.value = value;
    460 		if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) {
    461 			posted = 1;
    462 			SDL_PushEvent(&event);
    463 		}
    464 	}
    465 #endif /* !SDL_EVENTS_DISABLED */
    466 	return(posted);
    467 }
    468 
    469 int SDL_PrivateJoystickBall(SDL_Joystick *joystick, Uint8 ball,
    470 					Sint16 xrel, Sint16 yrel)
    471 {
    472 	int posted;
    473 
    474 	/* Update internal mouse state */
    475 	joystick->balls[ball].dx += xrel;
    476 	joystick->balls[ball].dy += yrel;
    477 
    478 	/* Post the event, if desired */
    479 	posted = 0;
    480 #if !SDL_EVENTS_DISABLED
    481 	if ( SDL_ProcessEvents[SDL_JOYBALLMOTION] == SDL_ENABLE ) {
    482 		SDL_Event event;
    483 		event.jball.type = SDL_JOYBALLMOTION;
    484 		event.jball.which = joystick->index;
    485 		event.jball.ball = ball;
    486 		event.jball.xrel = xrel;
    487 		event.jball.yrel = yrel;
    488 		if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) {
    489 			posted = 1;
    490 			SDL_PushEvent(&event);
    491 		}
    492 	}
    493 #endif /* !SDL_EVENTS_DISABLED */
    494 	return(posted);
    495 }
    496 
    497 int SDL_PrivateJoystickButton(SDL_Joystick *joystick, Uint8 button, Uint8 state)
    498 {
    499 	int posted;
    500 #if !SDL_EVENTS_DISABLED
    501 	SDL_Event event;
    502 
    503 	switch ( state ) {
    504 		case SDL_PRESSED:
    505 			event.type = SDL_JOYBUTTONDOWN;
    506 			break;
    507 		case SDL_RELEASED:
    508 			event.type = SDL_JOYBUTTONUP;
    509 			break;
    510 		default:
    511 			/* Invalid state -- bail */
    512 			return(0);
    513 	}
    514 #endif /* !SDL_EVENTS_DISABLED */
    515 
    516 	/* Update internal joystick state */
    517 	joystick->buttons[button] = state;
    518 
    519 	/* Post the event, if desired */
    520 	posted = 0;
    521 #if !SDL_EVENTS_DISABLED
    522 	if ( SDL_ProcessEvents[event.type] == SDL_ENABLE ) {
    523 		event.jbutton.which = joystick->index;
    524 		event.jbutton.button = button;
    525 		event.jbutton.state = state;
    526 		if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) {
    527 			posted = 1;
    528 			SDL_PushEvent(&event);
    529 		}
    530 	}
    531 #endif /* !SDL_EVENTS_DISABLED */
    532 	return(posted);
    533 }
    534 
    535 void SDL_JoystickUpdate(void)
    536 {
    537 	int i;
    538 
    539 	for ( i=0; SDL_joysticks[i]; ++i ) {
    540 		SDL_SYS_JoystickUpdate(SDL_joysticks[i]);
    541 	}
    542 }
    543 
    544 int SDL_JoystickEventState(int state)
    545 {
    546 #if SDL_EVENTS_DISABLED
    547 	return SDL_IGNORE;
    548 #else
    549 	const Uint8 event_list[] = {
    550 		SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION,
    551 		SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP,
    552 	};
    553 	unsigned int i;
    554 
    555 	switch (state) {
    556 		case SDL_QUERY:
    557 			state = SDL_IGNORE;
    558 			for ( i=0; i<SDL_arraysize(event_list); ++i ) {
    559 				state = SDL_EventState(event_list[i],SDL_QUERY);
    560 				if ( state == SDL_ENABLE ) {
    561 					break;
    562 				}
    563 			}
    564 			break;
    565 		default:
    566 			for ( i=0; i<SDL_arraysize(event_list); ++i ) {
    567 				SDL_EventState(event_list[i], state);
    568 			}
    569 			break;
    570 	}
    571 	return(state);
    572 #endif /* SDL_EVENTS_DISABLED */
    573 }
    574