src/joystick/SDL_joystick.c
author Sam Lantinga <slouken@libsdl.org>
Sat, 25 Feb 2006 15:01:44 +0000
changeset 1429 aff0170f9f1b
parent 1402 d910939febfa
child 1612 97d0966f4bf7
permissions -rw-r--r--
Date: Sat, 25 Feb 2006 14:26:19 +0100 (CET)
From: "Torsten Giebl"
Subject: [SDL] testpalette.diff

To get rid of Mousecursor Fullscreen problems on Mac OSX.
     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@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 	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 }