ported dfinput to osx as well (prelimiary, no config dialog yet). will eventually replace HIDInput.

git-svn-id: https://pcsxr.svn.codeplex.com/svn/pcsxr@55128 e17a0e51-4ae3-4d35-97c3-1a29b211df97

7 files changed, 1845 insertions, 0 deletions

diff --git a/macosx/plugins/DFInput/SDL/src/SDL.c b/macosx/plugins/DFInput/SDL/src/SDL.c
new file mode 100644
index 00000000..4d6a98c0
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/SDL.c
@@ -0,0 +1,97 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+// 7-25-2010 Wei Mingzhi
+// Removed everything unrelated to Mac OS X Joystick support.
+
+#include "SDL_config.h"
+
+/* Initialization code for SDL */
+
+#include "SDL.h"
+
+/* Initialization/Cleanup routines */
+extern int  SDL_JoystickInit(void);
+extern void SDL_JoystickQuit(void);
+
+/* The current SDL version */
+static SDL_version version = 
+	{ SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL };
+
+/* The initialized subsystems */
+static Uint32 SDL_initialized = 0;
+
+int SDL_InitSubSystem(Uint32 flags)
+{
+	/* Initialize the joystick subsystem */
+	if ( (flags & SDL_INIT_JOYSTICK) &&
+	     !(SDL_initialized & SDL_INIT_JOYSTICK) ) {
+		if ( SDL_JoystickInit() < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_JOYSTICK;
+	}
+
+	return(0);
+}
+
+int SDL_Init(Uint32 flags)
+{
+	/* Clear the error message */
+	SDL_ClearError();
+
+	/* Initialize the desired subsystems */
+	if ( SDL_InitSubSystem(flags) < 0 ) {
+		return(-1);
+	}
+
+	return(0);
+}
+
+void SDL_QuitSubSystem(Uint32 flags)
+{
+	/* Shut down requested initialized subsystems */
+	if ( (flags & SDL_initialized & SDL_INIT_JOYSTICK) ) {
+		SDL_JoystickQuit();
+		SDL_initialized &= ~SDL_INIT_JOYSTICK;
+	}
+}
+
+Uint32 SDL_WasInit(Uint32 flags)
+{
+	if ( ! flags ) {
+		flags = SDL_INIT_EVERYTHING;
+	}
+	return (SDL_initialized&flags);
+}
+
+void SDL_Quit(void)
+{
+	/* Quit all subsystems */
+	SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
+}
+
+/* Return the library version number */
+const SDL_version * SDL_Linked_Version(void)
+{
+	return(&version);
+}
diff --git a/macosx/plugins/DFInput/SDL/src/SDL_error.c b/macosx/plugins/DFInput/SDL/src/SDL_error.c
new file mode 100644
index 00000000..11632f28
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/SDL_error.c
@@ -0,0 +1,238 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Simple error handling in SDL */
+
+#include "SDL_error.h"
+#include "SDL_error_c.h"
+
+/* Routine to get the thread-specific error variable */
+#if SDL_THREADS_DISABLED
+/* The  SDL_arraysize(The ),default (non-thread-safe) global error variable */
+static SDL_error SDL_global_error;
+#define SDL_GetErrBuf()	(&SDL_global_error)
+#else
+extern SDL_error *SDL_GetErrBuf(void);
+#endif /* SDL_THREADS_DISABLED */
+
+#define SDL_ERRBUFIZE	1024
+
+/* Private functions */
+
+static const char *SDL_LookupString(const char *key)
+{
+	/* FIXME: Add code to lookup key in language string hash-table */
+	return key;
+}
+
+/* Public functions */
+
+void SDL_SetError (const char *fmt, ...)
+{
+	va_list ap;
+	SDL_error *error;
+
+	/* Copy in the key, mark error as valid */
+	error = SDL_GetErrBuf();
+	error->error = 1;
+	SDL_strlcpy((char *)error->key, fmt, sizeof(error->key));
+
+	va_start(ap, fmt);
+	error->argc = 0;
+	while ( *fmt ) {
+		if ( *fmt++ == '%' ) {
+			while ( *fmt == '.' || (*fmt >= '0' && *fmt <= '9') ) {
+				++fmt;
+			}
+			switch (*fmt++) {
+			    case 0:  /* Malformed format string.. */
+				--fmt;
+				break;
+			    case 'c':
+			    case 'i':
+			    case 'd':
+			    case 'u':
+			    case 'o':
+			    case 'x':
+			    case 'X':
+				error->args[error->argc++].value_i =
+							va_arg(ap, int);
+				break;
+			    case 'f':
+				error->args[error->argc++].value_f =
+							va_arg(ap, double);
+				break;
+			    case 'p':
+				error->args[error->argc++].value_ptr =
+							va_arg(ap, void *);
+				break;
+			    case 's':
+				{
+				  int i = error->argc;
+				  const char *str = va_arg(ap, const char *);
+				  if (str == NULL)
+				      str = "(null)";
+				  SDL_strlcpy((char *)error->args[i].buf, str, ERR_MAX_STRLEN);
+				  error->argc++;
+				}
+				break;
+			    default:
+				break;
+			}
+			if ( error->argc >= ERR_MAX_ARGS ) {
+				break;
+			}
+		}
+	}
+	va_end(ap);
+
+	/* If we are in debug mode, print out an error message */
+#ifdef DEBUG_ERROR
+	fprintf(stderr, "SDL_SetError: %s\n", SDL_GetError());
+#endif
+}
+
+/* This function has a bit more overhead than most error functions
+   so that it supports internationalization and thread-safe errors.
+*/
+char *SDL_GetErrorMsg(char *errstr, unsigned int maxlen)
+{
+	SDL_error *error;
+
+	/* Clear the error string */
+	*errstr = '\0'; --maxlen;
+
+	/* Get the thread-safe error, and print it out */
+	error = SDL_GetErrBuf();
+	if ( error->error ) {
+		const char *fmt;
+		char *msg = errstr;
+		int len;
+		int argi;
+
+		fmt = SDL_LookupString(error->key);
+		argi = 0;
+		while ( *fmt && (maxlen > 0) ) {
+			if ( *fmt == '%' ) {
+				char tmp[32], *spot = tmp;
+				*spot++ = *fmt++;
+				while ( (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) && spot < (tmp+SDL_arraysize(tmp)-2) ) {
+					*spot++ = *fmt++;
+				}
+				*spot++ = *fmt++;
+				*spot++ = '\0';
+				switch (spot[-2]) {
+				    case '%':
+					*msg++ = '%';
+					maxlen -= 1;
+					break;
+				    case 'c':
+				    case 'i':
+			            case 'd':
+			            case 'u':
+			            case 'o':
+				    case 'x':
+				    case 'X':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_i);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 'f':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_f);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 'p':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_ptr);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 's':
+					len = SDL_snprintf(msg, maxlen, tmp, SDL_LookupString(error->args[argi++].buf));
+					msg += len;
+					maxlen -= len;
+					break;
+				}
+			} else {
+				*msg++ = *fmt++;
+				maxlen -= 1;
+			}
+		}
+		*msg = 0;	/* NULL terminate the string */
+	}
+	return(errstr);
+}
+
+/* Available for backwards compatibility */
+char *SDL_GetError (void)
+{
+	static char errmsg[SDL_ERRBUFIZE];
+
+	return((char *)SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE));
+}
+
+void SDL_ClearError(void)
+{
+	SDL_error *error;
+
+	error = SDL_GetErrBuf();
+	error->error = 0;
+}
+
+/* Very common errors go here */
+void SDL_Error(SDL_errorcode code)
+{
+	switch (code) {
+		case SDL_ENOMEM:
+			SDL_SetError("Out of memory");
+			break;
+		case SDL_EFREAD:
+			SDL_SetError("Error reading from datastream");
+			break;
+		case SDL_EFWRITE:
+			SDL_SetError("Error writing to datastream");
+			break;
+		case SDL_EFSEEK:
+			SDL_SetError("Error seeking in datastream");
+			break;
+		default:
+			SDL_SetError("Unknown SDL error");
+			break;
+	}
+}
+
+#ifdef TEST_ERROR
+int main(int argc, char *argv[])
+{
+	char buffer[BUFSIZ+1];
+
+	SDL_SetError("Hi there!");
+	printf("Error 1: %s\n", SDL_GetError());
+	SDL_ClearError();
+	SDL_memset(buffer, '1', BUFSIZ);
+	buffer[BUFSIZ] = 0;
+	SDL_SetError("This is the error: %s (%f)", buffer, 1.0);
+	printf("Error 2: %s\n", SDL_GetError());
+	exit(0);
+}
+#endif
diff --git a/macosx/plugins/DFInput/SDL/src/SDL_error_c.h b/macosx/plugins/DFInput/SDL/src/SDL_error_c.h
new file mode 100644
index 00000000..990acb56
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/SDL_error_c.h
@@ -0,0 +1,58 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This file defines a structure that carries language-independent
+   error messages
+*/
+
+#ifndef _SDL_error_c_h
+#define _SDL_error_c_h
+
+#define ERR_MAX_STRLEN	128
+#define ERR_MAX_ARGS	5
+
+typedef struct SDL_error {
+	/* This is a numeric value corresponding to the current error */
+	int error;
+
+	/* This is a key used to index into a language hashtable containing
+	   internationalized versions of the SDL error messages.  If the key
+	   is not in the hashtable, or no hashtable is available, the key is
+	   used directly as an error message format string.
+	*/
+	char key[ERR_MAX_STRLEN];
+
+	/* These are the arguments for the error functions */
+	int argc;
+	union {
+		void *value_ptr;
+#if 0	/* What is a character anyway?  (UNICODE issues) */
+		unsigned char value_c;
+#endif
+		int value_i;
+		double value_f;
+		char buf[ERR_MAX_STRLEN];
+	} args[ERR_MAX_ARGS];
+} SDL_error;
+
+#endif /* _SDL_error_c_h */
diff --git a/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick.c b/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick.c
new file mode 100644
index 00000000..add306a5
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick.c
@@ -0,0 +1,481 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+// 7-25-2010 Wei Mingzhi
+// Removed everything unrelated to Mac OS X Joystick support.
+
+#include "SDL.h"
+
+/* This is the joystick API for Simple DirectMedia Layer */
+
+#include "SDL_sysjoystick.h"
+#include "SDL_joystick_c.h"
+
+#define SDL_Lock_EventThread()
+#define SDL_Unlock_EventThread()
+
+Uint8 SDL_numjoysticks = 0;
+SDL_Joystick **SDL_joysticks = NULL;
+static SDL_Joystick *default_joystick = NULL;
+
+int SDL_JoystickInit(void)
+{
+	int arraylen;
+	int status;
+
+	SDL_numjoysticks = 0;
+	status = SDL_SYS_JoystickInit();
+	if ( status >= 0 ) {
+		arraylen = (status+1)*sizeof(*SDL_joysticks);
+		SDL_joysticks = (SDL_Joystick **)SDL_malloc(arraylen);
+		if ( SDL_joysticks == NULL ) {
+			SDL_numjoysticks = 0;
+		} else {
+			SDL_memset(SDL_joysticks, 0, arraylen);
+			SDL_numjoysticks = status;
+		}
+		status = 0;
+	}
+	default_joystick = NULL;
+	return(status);
+}
+
+/*
+ * Count the number of joysticks attached to the system
+ */
+int SDL_NumJoysticks(void)
+{
+	return SDL_numjoysticks;
+}
+
+/*
+ * Get the implementation dependent name of a joystick
+ */
+const char *SDL_JoystickName(int device_index)
+{
+	if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) {
+		SDL_SetError("There are %d joysticks available",
+		             SDL_numjoysticks);
+		return(NULL);
+	}
+	return(SDL_SYS_JoystickName(device_index));
+}
+
+/*
+ * Open a joystick for use - the index passed as an argument refers to
+ * the N'th joystick on the system.  This index is the value which will
+ * identify this joystick in future joystick events.
+ *
+ * This function returns a joystick identifier, or NULL if an error occurred.
+ */
+SDL_Joystick *SDL_JoystickOpen(int device_index)
+{
+	int i;
+	SDL_Joystick *joystick;
+
+	if ( (device_index < 0) || (device_index >= SDL_numjoysticks) ) {
+		SDL_SetError("There are %d joysticks available",
+		             SDL_numjoysticks);
+		return(NULL);
+	}
+
+	/* If the joystick is already open, return it */
+	for ( i=0; SDL_joysticks[i]; ++i ) {
+		if ( device_index == SDL_joysticks[i]->index ) {
+			joystick = SDL_joysticks[i];
+			++joystick->ref_count;
+			return(joystick);
+		}
+	}
+
+	/* Create and initialize the joystick */
+	joystick = (SDL_Joystick *)SDL_malloc((sizeof *joystick));
+	if ( joystick != NULL ) {
+		SDL_memset(joystick, 0, (sizeof *joystick));
+		joystick->index = device_index;
+		if ( SDL_SYS_JoystickOpen(joystick) < 0 ) {
+			SDL_free(joystick);
+			joystick = NULL;
+		} else {
+			if ( joystick->naxes > 0 ) {
+				joystick->axes = (Sint16 *)SDL_malloc
+					(joystick->naxes*sizeof(Sint16));
+			}
+			if ( joystick->nhats > 0 ) {
+				joystick->hats = (Uint8 *)SDL_malloc
+					(joystick->nhats*sizeof(Uint8));
+			}
+			if ( joystick->nballs > 0 ) {
+				joystick->balls = (struct balldelta *)SDL_malloc
+				  (joystick->nballs*sizeof(*joystick->balls));
+			}
+			if ( joystick->nbuttons > 0 ) {
+				joystick->buttons = (Uint8 *)SDL_malloc
+					(joystick->nbuttons*sizeof(Uint8));
+			}
+			if ( ((joystick->naxes > 0) && !joystick->axes)
+			  || ((joystick->nhats > 0) && !joystick->hats)
+			  || ((joystick->nballs > 0) && !joystick->balls)
+			  || ((joystick->nbuttons > 0) && !joystick->buttons)) {
+				SDL_OutOfMemory();
+				SDL_JoystickClose(joystick);
+				joystick = NULL;
+			}
+			if ( joystick->axes ) {
+				SDL_memset(joystick->axes, 0,
+					joystick->naxes*sizeof(Sint16));
+			}
+			if ( joystick->hats ) {
+				SDL_memset(joystick->hats, 0,
+					joystick->nhats*sizeof(Uint8));
+			}
+			if ( joystick->balls ) {
+				SDL_memset(joystick->balls, 0,
+				  joystick->nballs*sizeof(*joystick->balls));
+			}
+			if ( joystick->buttons ) {
+				SDL_memset(joystick->buttons, 0,
+					joystick->nbuttons*sizeof(Uint8));
+			}
+		}
+	}
+	if ( joystick ) {
+		/* Add joystick to list */
+		++joystick->ref_count;
+		SDL_Lock_EventThread();
+		for ( i=0; SDL_joysticks[i]; ++i )
+			/* Skip to next joystick */;
+		SDL_joysticks[i] = joystick;
+		SDL_Unlock_EventThread();
+	}
+	return(joystick);
+}
+
+/*
+ * Returns 1 if the joystick has been opened, or 0 if it has not.
+ */
+int SDL_JoystickOpened(int device_index)
+{
+	int i, opened;
+
+	opened = 0;
+	for ( i=0; SDL_joysticks[i]; ++i ) {
+		if ( SDL_joysticks[i]->index == (Uint8)device_index ) {
+			opened = 1;
+			break;
+		}
+	}
+	return(opened);
+}
+
+static int ValidJoystick(SDL_Joystick **joystick)
+{
+	int valid;
+
+	if ( *joystick == NULL ) {
+		*joystick = default_joystick;
+	}
+	if ( *joystick == NULL ) {
+		SDL_SetError("Joystick hasn't been opened yet");
+		valid = 0;
+	} else {
+		valid = 1;
+	}
+	return valid;
+}
+
+/*
+ * Get the device index of an opened joystick.
+ */
+int SDL_JoystickIndex(SDL_Joystick *joystick)
+{
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+	return(joystick->index);
+}
+
+/*
+ * Get the number of multi-dimensional axis controls on a joystick
+ */
+int SDL_JoystickNumAxes(SDL_Joystick *joystick)
+{
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+	return(joystick->naxes);
+}
+
+/*
+ * Get the number of hats on a joystick
+ */
+int SDL_JoystickNumHats(SDL_Joystick *joystick)
+{
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+	return(joystick->nhats);
+}
+
+/*
+ * Get the number of trackballs on a joystick
+ */
+int SDL_JoystickNumBalls(SDL_Joystick *joystick)
+{
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+	return(joystick->nballs);
+}
+
+/*
+ * Get the number of buttons on a joystick
+ */
+int SDL_JoystickNumButtons(SDL_Joystick *joystick)
+{
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+	return(joystick->nbuttons);
+}
+
+/*
+ * Get the current state of an axis control on a joystick
+ */
+Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis)
+{
+	Sint16 state;
+
+	if ( ! ValidJoystick(&joystick) ) {
+		return(0);
+	}
+	if ( axis < joystick->naxes ) {
+		state = joystick->axes[axis];
+	} else {
+		SDL_SetError("Joystick only has %d axes", joystick->naxes);
+		state = 0;
+	}
+	return(state);
+}
+
+/*
+ * Get the current state of a hat on a joystick
+ */
+Uint8 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat)
+{
+	Uint8 state;
+
+	if ( ! ValidJoystick(&joystick) ) {
+		return(0);
+	}
+	if ( hat < joystick->nhats ) {
+		state = joystick->hats[hat];
+	} else {
+		SDL_SetError("Joystick only has %d hats", joystick->nhats);
+		state = 0;
+	}
+	return(state);
+}
+
+/*
+ * Get the ball axis change since the last poll
+ */
+int SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy)
+{
+	int retval;
+
+	if ( ! ValidJoystick(&joystick) ) {
+		return(-1);
+	}
+
+	retval = 0;
+	if ( ball < joystick->nballs ) {
+		if ( dx ) {
+			*dx = joystick->balls[ball].dx;
+		}
+		if ( dy ) {
+			*dy = joystick->balls[ball].dy;
+		}
+		joystick->balls[ball].dx = 0;
+		joystick->balls[ball].dy = 0;
+	} else {
+		SDL_SetError("Joystick only has %d balls", joystick->nballs);
+		retval = -1;
+	}
+	return(retval);
+}
+
+/*
+ * Get the current state of a button on a joystick
+ */
+Uint8 SDL_JoystickGetButton(SDL_Joystick *joystick, int button)
+{
+	Uint8 state;
+
+	if ( ! ValidJoystick(&joystick) ) {
+		return(0);
+	}
+	if ( button < joystick->nbuttons ) {
+		state = joystick->buttons[button];
+	} else {
+		SDL_SetError("Joystick only has %d buttons",joystick->nbuttons);
+		state = 0;
+	}
+	return(state);
+}
+
+/*
+ * Close a joystick previously opened with SDL_JoystickOpen()
+ */
+void SDL_JoystickClose(SDL_Joystick *joystick)
+{
+	int i;
+
+	if ( ! ValidJoystick(&joystick) ) {
+		return;
+	}
+
+	/* First decrement ref count */
+	if ( --joystick->ref_count > 0 ) {
+		return;
+	}
+
+	/* Lock the event queue - prevent joystick polling */
+	SDL_Lock_EventThread();
+
+	if ( joystick == default_joystick ) {
+		default_joystick = NULL;
+	}
+	SDL_SYS_JoystickClose(joystick);
+
+	/* Remove joystick from list */
+	for ( i=0; SDL_joysticks[i]; ++i ) {
+		if ( joystick == SDL_joysticks[i] ) {
+			SDL_memcpy(&SDL_joysticks[i], &SDL_joysticks[i+1],
+			       (SDL_numjoysticks-i)*sizeof(joystick));
+			break;
+		}
+	}
+
+	/* Let the event thread keep running */
+	SDL_Unlock_EventThread();
+
+	/* Free the data associated with this joystick */
+	if ( joystick->axes ) {
+		SDL_free(joystick->axes);
+	}
+	if ( joystick->hats ) {
+		SDL_free(joystick->hats);
+	}
+	if ( joystick->balls ) {
+		SDL_free(joystick->balls);
+	}
+	if ( joystick->buttons ) {
+		SDL_free(joystick->buttons);
+	}
+	SDL_free(joystick);
+}
+
+void SDL_JoystickQuit(void)
+{
+	/* Stop the event polling */
+	SDL_Lock_EventThread();
+	SDL_numjoysticks = 0;
+	SDL_Unlock_EventThread();
+
+	/* Quit the joystick setup */
+	SDL_SYS_JoystickQuit();
+	if ( SDL_joysticks ) {
+		SDL_free(SDL_joysticks);
+		SDL_joysticks = NULL;
+	}
+}
+
+
+/* These are global for SDL_sysjoystick.c and SDL_events.c */
+
+int SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value)
+{
+	int posted;
+
+	/* Update internal joystick state */
+	joystick->axes[axis] = value;
+
+	/* Post the event, if desired */
+	posted = 0;
+
+	return(posted);
+}
+
+int SDL_PrivateJoystickHat(SDL_Joystick *joystick, Uint8 hat, Uint8 value)
+{
+	int posted;
+
+	/* Update internal joystick state */
+	joystick->hats[hat] = value;
+
+	/* Post the event, if desired */
+	posted = 0;
+
+	return(posted);
+}
+
+int SDL_PrivateJoystickBall(SDL_Joystick *joystick, Uint8 ball,
+					Sint16 xrel, Sint16 yrel)
+{
+	int posted;
+
+	/* Update internal mouse state */
+	joystick->balls[ball].dx += xrel;
+	joystick->balls[ball].dy += yrel;
+
+	/* Post the event, if desired */
+	posted = 0;
+
+	return(posted);
+}
+
+int SDL_PrivateJoystickButton(SDL_Joystick *joystick, Uint8 button, Uint8 state)
+{
+	int posted;
+
+	/* Update internal joystick state */
+	joystick->buttons[button] = state;
+
+	/* Post the event, if desired */
+	posted = 0;
+
+	return(posted);
+}
+
+void SDL_JoystickUpdate(void)
+{
+	int i;
+
+	for ( i=0; SDL_joysticks[i]; ++i ) {
+		SDL_SYS_JoystickUpdate(SDL_joysticks[i]);
+	}
+}
+
+int SDL_JoystickEventState(int state)
+{
+	return SDL_IGNORE;
+}
diff --git a/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick_c.h b/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick_c.h
new file mode 100644
index 00000000..032751cc
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/joystick/SDL_joystick_c.h
@@ -0,0 +1,41 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+// 7-25-2010 Wei Mingzhi
+// Removed everything unrelated to Mac OS X Joystick support.
+
+#include "SDL_config.h"
+
+/* Useful functions and variables from SDL_joystick.c */
+#include "SDL_joystick.h"
+
+/* The number of available joysticks on the system */
+extern Uint8 SDL_numjoysticks;
+
+/* Internal event queueing functions */
+extern int SDL_PrivateJoystickAxis(SDL_Joystick *joystick,
+                                   Uint8 axis, Sint16 value);
+extern int SDL_PrivateJoystickBall(SDL_Joystick *joystick,
+                                   Uint8 ball, Sint16 xrel, Sint16 yrel);
+extern int SDL_PrivateJoystickHat(SDL_Joystick *joystick,
+                                 Uint8 hat, Uint8 value);
+extern int SDL_PrivateJoystickButton(SDL_Joystick *joystick,
+                                     Uint8 button, Uint8 state);
diff --git a/macosx/plugins/DFInput/SDL/src/joystick/SDL_sysjoystick.h b/macosx/plugins/DFInput/SDL/src/joystick/SDL_sysjoystick.h
new file mode 100644
index 00000000..48fbb3cf
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/joystick/SDL_sysjoystick.h
@@ -0,0 +1,85 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+// 7-25-2010 Wei Mingzhi
+// Removed everything unrelated to Mac OS X Joystick support.
+
+#include "SDL_config.h"
+
+/* This is the system specific header for the SDL joystick API */
+
+#include "SDL_joystick.h"
+
+/* The SDL joystick structure */
+struct _SDL_Joystick {
+	Uint8 index;		/* Device index */
+	const char *name;	/* Joystick name - system dependent */
+
+	int naxes;		/* Number of axis controls on the joystick */
+	Sint16 *axes;		/* Current axis states */
+
+	int nhats;		/* Number of hats on the joystick */
+	Uint8 *hats;		/* Current hat states */
+	
+	int nballs;		/* Number of trackballs on the joystick */
+	struct balldelta {
+		int dx;
+		int dy;
+	} *balls;		/* Current ball motion deltas */
+	
+	int nbuttons;		/* Number of buttons on the joystick */
+	Uint8 *buttons;		/* Current button states */
+	
+	struct joystick_hwdata *hwdata;	/* Driver dependent information */
+
+	int ref_count;		/* Reference count for multiple opens */
+};
+
+/* Function to scan the system for joysticks.
+ * Joystick 0 should be the system default joystick.
+ * This function should return the number of available joysticks, or -1
+ * on an unrecoverable fatal error.
+ */
+extern int SDL_SYS_JoystickInit(void);
+
+/* Function to get the device-dependent name of a joystick */
+extern const char *SDL_SYS_JoystickName(int index);
+
+/* Function to open a joystick for use.
+   The joystick to open is specified by the index field of the joystick.
+   This should fill the nbuttons and naxes fields of the joystick structure.
+   It returns 0, or -1 if there is an error.
+ */
+extern int SDL_SYS_JoystickOpen(SDL_Joystick *joystick);
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+extern void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick);
+
+/* Function to close a joystick after use */
+extern void SDL_SYS_JoystickClose(SDL_Joystick *joystick);
+
+/* Function to perform any system-specific joystick related cleanup */
+extern void SDL_SYS_JoystickQuit(void);
+
diff --git a/macosx/plugins/DFInput/SDL/src/joystick/darwin/SDL_sysjoystick.c b/macosx/plugins/DFInput/SDL/src/joystick/darwin/SDL_sysjoystick.c
new file mode 100644
index 00000000..b89e8332
--- /dev/null
+++ b/macosx/plugins/DFInput/SDL/src/joystick/darwin/SDL_sysjoystick.c
@@ -0,0 +1,845 @@
+/*
+	SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Library General Public
+	License as published by the Free Software Foundation; either
+	version 2 of the License, or (at your option) any later version.
+
+	This library is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Library General Public License for more details.
+
+	You should have received a copy of the GNU Library General Public
+	License along with this library; if not, write to the Free
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	Sam Lantinga
+	slouken@libsdl.org
+*/
+// 7-25-2010 Wei Mingzhi
+// Removed everything unrelated to Mac OS X Joystick support.
+
+#include "SDL_config.h"
+
+#ifdef SDL_JOYSTICK_IOKIT
+
+/* SDL joystick driver for Darwin / Mac OS X, based on the IOKit HID API */
+/* Written 2001 by Max Horn */
+
+#include <unistd.h>
+#include <ctype.h>
+#include <sysexits.h>
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#ifdef MACOS_10_0_4
+#include <IOKit/hidsystem/IOHIDUsageTables.h>
+#else
+/* The header was moved here in Mac OS X 10.1 */
+#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
+#endif
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <Carbon/Carbon.h> /* for NewPtrClear, DisposePtr */
+
+#include "SDL_joystick.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+struct recElement
+{
+	IOHIDElementCookie cookie;				/* unique value which identifies element, will NOT change */
+	long min;								/* reported min value possible */
+	long max;								/* reported max value possible */
+#if 0
+	/* TODO: maybe should handle the following stuff somehow? */
+
+	long scaledMin;							/* reported scaled min value possible */
+	long scaledMax;							/* reported scaled max value possible */
+	long size;								/* size in bits of data return from element */
+	Boolean relative;						/* are reports relative to last report (deltas) */
+	Boolean wrapping;						/* does element wrap around (one value higher than max is min) */
+	Boolean nonLinear;						/* are the values reported non-linear relative to element movement */
+	Boolean preferredState;					/* does element have a preferred state (such as a button) */
+	Boolean nullState;						/* does element have null state */
+#endif /* 0 */
+
+	/* runtime variables used for auto-calibration */
+	long minReport;							/* min returned value */
+	long maxReport;							/* max returned value */
+	
+	struct recElement * pNext;				/* next element in list */
+};
+typedef struct recElement recElement;
+
+struct joystick_hwdata
+{
+	IOHIDDeviceInterface ** interface;		/* interface to device, NULL = no interface */
+
+	char product[256];							/* name of product */
+	long usage;								/* usage page from IOUSBHID Parser.h which defines general usage */
+	long usagePage;							/* usage within above page from IOUSBHID Parser.h which defines specific usage */
+
+	long axes;								/* number of axis (calculated, not reported by device) */
+	long buttons;							/* number of buttons (calculated, not reported by device) */
+	long hats;								/* number of hat switches (calculated, not reported by device) */
+	long elements;							/* number of total elements (shouldbe total of above) (calculated, not reported by device) */
+
+	recElement* firstAxis;
+	recElement* firstButton;
+	recElement* firstHat;
+
+	int removed;
+	int uncentered;
+
+	struct joystick_hwdata* pNext;			/* next device */
+};
+typedef struct joystick_hwdata recDevice;
+
+
+/* Linked list of all available devices */
+static recDevice *gpDeviceList = NULL;
+
+
+static void HIDReportErrorNum (char * strError, long numError)
+{
+	SDL_SetError(strError);
+}
+
+static void HIDGetCollectionElements (CFMutableDictionaryRef deviceProperties, recDevice *pDevice);
+
+/* returns current value for element, polling element
+ * will return 0 on error conditions which should be accounted for by application
+ */
+
+static SInt32 HIDGetElementValue (recDevice *pDevice, recElement *pElement)
+{
+	IOReturn result = kIOReturnSuccess;
+	IOHIDEventStruct hidEvent;
+	hidEvent.value = 0;
+	
+	if (NULL != pDevice && NULL != pElement && NULL != pDevice->interface)
+	{
+		result = (*(pDevice->interface))->getElementValue(pDevice->interface, pElement->cookie, &hidEvent);
+		if (kIOReturnSuccess == result)
+		{
+			/* record min and max for auto calibration */
+			if (hidEvent.value < pElement->minReport)
+				pElement->minReport = hidEvent.value;
+			if (hidEvent.value > pElement->maxReport)
+				pElement->maxReport = hidEvent.value;
+		}
+	}
+
+	/* auto user scale */
+	return hidEvent.value;
+}
+
+static SInt32 HIDScaledCalibratedValue (recDevice *pDevice, recElement *pElement, long min, long max)
+{
+	float deviceScale = max - min;
+	float readScale = pElement->maxReport - pElement->minReport;
+	SInt32 value = HIDGetElementValue(pDevice, pElement);
+	if (readScale == 0)
+		return value; /* no scaling at all */
+	else
+		return ((value - pElement->minReport) * deviceScale / readScale) + min;
+}
+
+
+static void HIDRemovalCallback(void * target,
+                               IOReturn result,
+                               void * refcon,
+                               void * sender)
+{
+	recDevice *device = (recDevice *) refcon;
+	device->removed = 1;
+	device->uncentered = 1;
+}
+
+
+
+/* Create and open an interface to device, required prior to extracting values or building queues.
+ * Note: appliction now owns the device and must close and release it prior to exiting
+ */
+
+static IOReturn HIDCreateOpenDeviceInterface (io_object_t hidDevice, recDevice *pDevice)
+{
+	IOReturn result = kIOReturnSuccess;
+	HRESULT plugInResult = S_OK;
+	SInt32 score = 0;
+	IOCFPlugInInterface ** ppPlugInInterface = NULL;
+	
+	if (NULL == pDevice->interface)
+	{
+		result = IOCreatePlugInInterfaceForService (hidDevice, kIOHIDDeviceUserClientTypeID,
+													kIOCFPlugInInterfaceID, &ppPlugInInterface, &score);
+		if (kIOReturnSuccess == result)
+		{
+			/* Call a method of the intermediate plug-in to create the device interface */
+			plugInResult = (*ppPlugInInterface)->QueryInterface (ppPlugInInterface,
+								CFUUIDGetUUIDBytes (kIOHIDDeviceInterfaceID), (void *) &(pDevice->interface));
+			if (S_OK != plugInResult)
+				HIDReportErrorNum ("CouldnÕô query HID class device interface from plugInInterface", plugInResult);
+			(*ppPlugInInterface)->Release (ppPlugInInterface);
+		}
+		else
+			HIDReportErrorNum ("Failed to create **plugInInterface via IOCreatePlugInInterfaceForService.", result);
+	}
+	if (NULL != pDevice->interface)
+	{
+		result = (*(pDevice->interface))->open (pDevice->interface, 0);
+		if (kIOReturnSuccess != result)
+			HIDReportErrorNum ("Failed to open pDevice->interface via open.", result);
+		else
+			(*(pDevice->interface))->setRemovalCallback (pDevice->interface, HIDRemovalCallback, pDevice, pDevice);
+
+	}
+	return result;
+}
+
+/* Closes and releases interface to device, should be done prior to exting application
+ * Note: will have no affect if device or interface do not exist
+ * application will "own" the device if interface is not closed
+ * (device may have to be plug and re-plugged in different location to get it working again without a restart)
+ */
+
+static IOReturn HIDCloseReleaseInterface (recDevice *pDevice)
+{
+	IOReturn result = kIOReturnSuccess;
+	
+	if ((NULL != pDevice) && (NULL != pDevice->interface))
+	{
+		/* close the interface */
+		result = (*(pDevice->interface))->close (pDevice->interface);
+		if (kIOReturnNotOpen == result)
+		{
+			/* do nothing as device was not opened, thus can't be closed */
+		}
+		else if (kIOReturnSuccess != result)
+			HIDReportErrorNum ("Failed to close IOHIDDeviceInterface.", result);
+		/* release the interface */
+		result = (*(pDevice->interface))->Release (pDevice->interface);
+		if (kIOReturnSuccess != result)
+			HIDReportErrorNum ("Failed to release IOHIDDeviceInterface.", result);
+		pDevice->interface = NULL;
+	}	
+	return result;
+}
+
+/* extracts actual specific element information from each element CF dictionary entry */
+
+static void HIDGetElementInfo (CFTypeRef refElement, recElement *pElement)
+{
+	long number;
+	CFTypeRef refType;
+
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementCookieKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->cookie = (IOHIDElementCookie) number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementMinKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->minReport = pElement->min = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementMaxKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->maxReport = pElement->max = number;
+/*
+	TODO: maybe should handle the following stuff somehow?
+
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMinKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->scaledMin = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMaxKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->scaledMax = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementSizeKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->size = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsRelativeKey));
+	if (refType)
+		pElement->relative = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsWrappingKey));
+	if (refType)
+		pElement->wrapping = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsNonLinearKey));
+	if (refType)
+		pElement->nonLinear = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasPreferedStateKey));
+	if (refType)
+		pElement->preferredState = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasNullStateKey));
+	if (refType)
+		pElement->nullState = CFBooleanGetValue (refType);
+*/
+}			
+
+/* examines CF dictionary vlaue in device element hierarchy to determine if it is element of interest or a collection of more elements
+ * if element of interest allocate storage, add to list and retrieve element specific info
+ * if collection then pass on to deconstruction collection into additional individual elements
+ */
+
+static void HIDAddElement (CFTypeRef refElement, recDevice* pDevice)
+{
+	recElement* element = NULL;
+	recElement** headElement = NULL;
+	long elementType, usagePage, usage;
+	CFTypeRef refElementType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementTypeKey));
+	CFTypeRef refUsagePage = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementUsagePageKey));
+	CFTypeRef refUsage = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementUsageKey));
+
+
+	if ((refElementType) && (CFNumberGetValue (refElementType, kCFNumberLongType, &elementType)))
+	{
+		/* look at types of interest */
+		if ((elementType == kIOHIDElementTypeInput_Misc) || (elementType == kIOHIDElementTypeInput_Button) ||
+			(elementType == kIOHIDElementTypeInput_Axis))
+		{
+			if (refUsagePage && CFNumberGetValue (refUsagePage, kCFNumberLongType, &usagePage) &&
+				refUsage && CFNumberGetValue (refUsage, kCFNumberLongType, &usage))
+			{
+				switch (usagePage) /* only interested in kHIDPage_GenericDesktop and kHIDPage_Button */
+				{
+					case kHIDPage_GenericDesktop:
+						{
+							switch (usage) /* look at usage to determine function */
+							{
+								case kHIDUsage_GD_X:
+								case kHIDUsage_GD_Y:
+								case kHIDUsage_GD_Z:
+								case kHIDUsage_GD_Rx:
+								case kHIDUsage_GD_Ry:
+								case kHIDUsage_GD_Rz:
+								case kHIDUsage_GD_Slider:
+								case kHIDUsage_GD_Dial:
+								case kHIDUsage_GD_Wheel:
+									element = (recElement *) NewPtrClear (sizeof (recElement));
+									if (element)
+									{
+										pDevice->axes++;
+										headElement = &(pDevice->firstAxis);
+									}
+								break;
+								case kHIDUsage_GD_Hatswitch:
+									element = (recElement *) NewPtrClear (sizeof (recElement));
+									if (element)
+									{
+										pDevice->hats++;
+										headElement = &(pDevice->firstHat);
+									}
+								break;
+							}							
+						}
+						break;
+					case kHIDPage_Button:
+						element = (recElement *) NewPtrClear (sizeof (recElement));
+						if (element)
+						{
+							pDevice->buttons++;
+							headElement = &(pDevice->firstButton);
+						}
+						break;
+					default:
+						break;
+				}
+			}
+		}
+		else if (kIOHIDElementTypeCollection == elementType)
+			HIDGetCollectionElements ((CFMutableDictionaryRef) refElement, pDevice);
+	}
+
+	if (element && headElement) /* add to list */
+	{
+		pDevice->elements++;
+		if (NULL == *headElement)
+			*headElement = element;
+		else
+		{
+			recElement *elementPrevious, *elementCurrent;
+			elementCurrent = *headElement;
+			while (elementCurrent)
+			{
+				elementPrevious = elementCurrent;
+				elementCurrent = elementPrevious->pNext;
+			}
+			elementPrevious->pNext = element;
+		}
+		element->pNext = NULL;
+		HIDGetElementInfo (refElement, element);
+	}
+}
+
+/* collects information from each array member in device element list (each array memeber = element) */
+
+static void HIDGetElementsCFArrayHandler (const void * value, void * parameter)
+{
+	if (CFGetTypeID (value) == CFDictionaryGetTypeID ())
+		HIDAddElement ((CFTypeRef) value, (recDevice *) parameter);
+}
+
+/* handles retrieval of element information from arrays of elements in device IO registry information */
+
+static void HIDGetElements (CFTypeRef refElementCurrent, recDevice *pDevice)
+{
+	CFTypeID type = CFGetTypeID (refElementCurrent);
+	if (type == CFArrayGetTypeID()) /* if element is an array */
+	{
+		CFRange range = {0, CFArrayGetCount (refElementCurrent)};
+		/* CountElementsCFArrayHandler called for each array member */
+		CFArrayApplyFunction (refElementCurrent, range, HIDGetElementsCFArrayHandler, pDevice);
+	}
+}			
+
+/* handles extracting element information from element collection CF types
+ * used from top level element decoding and hierarchy deconstruction to flatten device element list
+ */
+
+static void HIDGetCollectionElements (CFMutableDictionaryRef deviceProperties, recDevice *pDevice)
+{
+	CFTypeRef refElementTop = CFDictionaryGetValue (deviceProperties, CFSTR(kIOHIDElementKey));
+	if (refElementTop)
+		HIDGetElements (refElementTop, pDevice);
+}
+
+/* use top level element usage page and usage to discern device usage page and usage setting appropriate vlaues in device record */
+
+static void HIDTopLevelElementHandler (const void * value, void * parameter)
+{
+	CFTypeRef refCF = 0;
+	if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
+		return;
+	refCF = CFDictionaryGetValue (value, CFSTR(kIOHIDElementUsagePageKey));
+	if (!CFNumberGetValue (refCF, kCFNumberLongType, &((recDevice *) parameter)->usagePage))
+		SDL_SetError ("CFNumberGetValue error retrieving pDevice->usagePage.");
+	refCF = CFDictionaryGetValue (value, CFSTR(kIOHIDElementUsageKey));
+	if (!CFNumberGetValue (refCF, kCFNumberLongType, &((recDevice *) parameter)->usage))
+		SDL_SetError ("CFNumberGetValue error retrieving pDevice->usage.");
+}
+
+/* extracts device info from CF dictionary records in IO registry */
+
+static void HIDGetDeviceInfo (io_object_t hidDevice, CFMutableDictionaryRef hidProperties, recDevice *pDevice)
+{
+	CFMutableDictionaryRef usbProperties = 0;
+	io_registry_entry_t parent1, parent2;
+	
+	/* Mac OS X currently is not mirroring all USB properties to HID page so need to look at USB device page also
+	 * get dictionary for usb properties: step up two levels and get CF dictionary for USB properties
+	 */
+	if ((KERN_SUCCESS == IORegistryEntryGetParentEntry (hidDevice, kIOServicePlane, &parent1)) &&
+		(KERN_SUCCESS == IORegistryEntryGetParentEntry (parent1, kIOServicePlane, &parent2)) &&
+		(KERN_SUCCESS == IORegistryEntryCreateCFProperties (parent2, &usbProperties, kCFAllocatorDefault, kNilOptions)))
+	{
+		if (usbProperties)
+		{
+			CFTypeRef refCF = 0;
+			/* get device info
+			 * try hid dictionary first, if fail then go to usb dictionary
+			 */
+			
+			
+			/* get product name */
+			refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDProductKey));
+			if (!refCF)
+				refCF = CFDictionaryGetValue (usbProperties, CFSTR("USB Product Name"));
+			if (refCF)
+			{
+				if (!CFStringGetCString (refCF, pDevice->product, 256, CFStringGetSystemEncoding ()))
+					SDL_SetError ("CFStringGetCString error retrieving pDevice->product.");
+			}
+			
+			/* get usage page and usage */
+			refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDPrimaryUsagePageKey));
+			if (refCF)
+			{
+				if (!CFNumberGetValue (refCF, kCFNumberLongType, &pDevice->usagePage))
+					SDL_SetError ("CFNumberGetValue error retrieving pDevice->usagePage.");
+				refCF = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDPrimaryUsageKey));
+				if (refCF)
+					if (!CFNumberGetValue (refCF, kCFNumberLongType, &pDevice->usage))
+						SDL_SetError ("CFNumberGetValue error retrieving pDevice->usage.");
+			}
+
+			if (NULL == refCF) /* get top level element HID usage page or usage */
+			{
+				/* use top level element instead */
+				CFTypeRef refCFTopElement = 0;
+				refCFTopElement = CFDictionaryGetValue (hidProperties, CFSTR(kIOHIDElementKey));
+				{
+					/* refCFTopElement points to an array of element dictionaries */
+					CFRange range = {0, CFArrayGetCount (refCFTopElement)};
+					CFArrayApplyFunction (refCFTopElement, range, HIDTopLevelElementHandler, pDevice);
+				}
+			}
+
+			CFRelease (usbProperties);
+		}
+		else
+			SDL_SetError ("IORegistryEntryCreateCFProperties failed to create usbProperties.");
+
+		if (kIOReturnSuccess != IOObjectRelease (parent2))
+			SDL_SetError ("IOObjectRelease error with parent2.");
+		if (kIOReturnSuccess != IOObjectRelease (parent1))
+			SDL_SetError ("IOObjectRelease error with parent1.");
+	}
+}
+
+
+static recDevice *HIDBuildDevice (io_object_t hidDevice)
+{
+	recDevice *pDevice = (recDevice *) NewPtrClear (sizeof (recDevice));
+	if (pDevice)
+	{
+		/* get dictionary for HID properties */
+		CFMutableDictionaryRef hidProperties = 0;
+		kern_return_t result = IORegistryEntryCreateCFProperties (hidDevice, &hidProperties, kCFAllocatorDefault, kNilOptions);
+		if ((result == KERN_SUCCESS) && hidProperties)
+		{
+			/* create device interface */
+			result = HIDCreateOpenDeviceInterface (hidDevice, pDevice);
+			if (kIOReturnSuccess == result)
+			{
+				HIDGetDeviceInfo (hidDevice, hidProperties, pDevice); /* hidDevice used to find parents in registry tree */
+				HIDGetCollectionElements (hidProperties, pDevice);
+			}
+			else
+			{
+				DisposePtr((Ptr)pDevice);
+				pDevice = NULL;
+			}
+			CFRelease (hidProperties);
+		}
+		else
+		{
+			DisposePtr((Ptr)pDevice);
+			pDevice = NULL;
+		}
+	}
+	return pDevice;
+}
+
+/* disposes of the element list associated with a device and the memory associated with the list
+ */
+
+static void HIDDisposeElementList (recElement **elementList)
+{
+	recElement *pElement = *elementList;
+	while (pElement)
+	{
+		recElement *pElementNext = pElement->pNext;
+		DisposePtr ((Ptr) pElement);
+		pElement = pElementNext;
+	}
+	*elementList = NULL;
+}
+
+/* disposes of a single device, closing and releaseing interface, freeing memory fro device and elements, setting device pointer to NULL
+ * all your device no longer belong to us... (i.e., you do not 'own' the device anymore)
+ */
+
+static recDevice *HIDDisposeDevice (recDevice **ppDevice)
+{
+	kern_return_t result = KERN_SUCCESS;
+	recDevice *pDeviceNext = NULL;
+	if (*ppDevice)
+	{
+		/* save next device prior to disposing of this device */
+		pDeviceNext = (*ppDevice)->pNext;
+		
+		/* free element lists */
+		HIDDisposeElementList (&(*ppDevice)->firstAxis);
+		HIDDisposeElementList (&(*ppDevice)->firstButton);
+		HIDDisposeElementList (&(*ppDevice)->firstHat);
+		
+		result = HIDCloseReleaseInterface (*ppDevice); /* function sanity checks interface value (now application does not own device) */
+		if (kIOReturnSuccess != result)
+			HIDReportErrorNum ("HIDCloseReleaseInterface failed when trying to dipose device.", result);
+		DisposePtr ((Ptr)*ppDevice);
+		*ppDevice = NULL;
+	}
+	return pDeviceNext;
+}
+
+
+/* Function to scan the system for joysticks.
+ * Joystick 0 should be the system default joystick.
+ * This function should return the number of available joysticks, or -1
+ * on an unrecoverable fatal error.
+ */
+int SDL_SYS_JoystickInit(void)
+{
+	IOReturn result = kIOReturnSuccess;
+	mach_port_t masterPort = 0;
+	io_iterator_t hidObjectIterator = 0;
+	CFMutableDictionaryRef hidMatchDictionary = NULL;
+	recDevice *device, *lastDevice;
+	io_object_t ioHIDDeviceObject = 0;
+	
+	SDL_numjoysticks = 0;
+	
+	if (gpDeviceList)
+	{
+		SDL_SetError("Joystick: Device list already inited.");
+		return -1;
+	}
+	
+	result = IOMasterPort (bootstrap_port, &masterPort);
+	if (kIOReturnSuccess != result)
+	{
+		SDL_SetError("Joystick: IOMasterPort error with bootstrap_port.");
+		return -1;
+	}
+
+	/* Set up a matching dictionary to search I/O Registry by class name for all HID class devices. */
+	hidMatchDictionary = IOServiceMatching (kIOHIDDeviceKey);
+	if (hidMatchDictionary)
+	{
+		/* Add key for device type (joystick, in this case) to refine the matching dictionary. */
+		
+		/* NOTE: we now perform this filtering later
+		UInt32 usagePage = kHIDPage_GenericDesktop;
+		UInt32 usage = kHIDUsage_GD_Joystick;
+		CFNumberRef refUsage = NULL, refUsagePage = NULL;
+
+		refUsage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usage);
+		CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsageKey), refUsage);
+		refUsagePage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usagePage);
+		CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsagePageKey), refUsagePage);
+		*/
+	}
+	else
+	{
+		SDL_SetError("Joystick: Failed to get HID CFMutableDictionaryRef via IOServiceMatching.");
+		return -1;
+	}
+	
+	/*/ Now search I/O Registry for matching devices. */
+	result = IOServiceGetMatchingServices (masterPort, hidMatchDictionary, &hidObjectIterator);
+	/* Check for errors */
+	if (kIOReturnSuccess != result)
+	{
+		SDL_SetError("Joystick: Couldn't create a HID object iterator.");
+		return -1;
+	}
+	if (!hidObjectIterator) /* there are no joysticks */
+	{
+		gpDeviceList = NULL;
+		SDL_numjoysticks = 0;
+		return 0;
+	}
+	/* IOServiceGetMatchingServices consumes a reference to the dictionary, so we don't need to release the dictionary ref. */
+
+	/* build flat linked list of devices from device iterator */
+
+	gpDeviceList = lastDevice = NULL;
+	
+	while ((ioHIDDeviceObject = IOIteratorNext (hidObjectIterator)))
+	{
+		/* build a device record */
+		device = HIDBuildDevice (ioHIDDeviceObject);
+		if (!device)
+			continue;
+
+		/* dump device object, it is no longer needed */
+		result = IOObjectRelease (ioHIDDeviceObject);
+/*		if (KERN_SUCCESS != result)
+			HIDReportErrorNum ("IOObjectRelease error with ioHIDDeviceObject.", result);
+*/
+
+		/* Filter device list to non-keyboard/mouse stuff */ 
+		if ( (device->usagePage != kHIDPage_GenericDesktop) ||
+		     ((device->usage != kHIDUsage_GD_Joystick &&
+		      device->usage != kHIDUsage_GD_GamePad &&
+		      device->usage != kHIDUsage_GD_MultiAxisController)) ) {
+
+			/* release memory for the device */
+			HIDDisposeDevice (&device);
+			DisposePtr((Ptr)device);
+			continue;
+		}
+		
+		/* Add device to the end of the list */
+		if (lastDevice)
+			lastDevice->pNext = device;
+		else
+			gpDeviceList = device;
+		lastDevice = device;
+	}
+	result = IOObjectRelease (hidObjectIterator); /* release the iterator */
+
+	/* Count the total number of devices we found */
+	device = gpDeviceList;
+	while (device)
+	{
+		SDL_numjoysticks++;
+		device = device->pNext;
+	}
+	
+	return SDL_numjoysticks;
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *SDL_SYS_JoystickName(int index)
+{
+	recDevice *device = gpDeviceList;
+	
+	for (; index > 0; index--)
+		device = device->pNext;
+
+	return device->product;
+}
+
+/* Function to open a joystick for use.
+ * The joystick to open is specified by the index field of the joystick.
+ * This should fill the nbuttons and naxes fields of the joystick structure.
+ * It returns 0, or -1 if there is an error.
+ */
+int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
+{
+	recDevice *device = gpDeviceList;
+	int index;
+	
+	for (index = joystick->index; index > 0; index--)
+		device = device->pNext;
+
+	joystick->hwdata = device;
+	joystick->name = device->product;
+
+	joystick->naxes = device->axes;
+	joystick->nhats = device->hats;
+	joystick->nballs = 0;
+	joystick->nbuttons = device->buttons;
+
+	return 0;
+}
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
+{
+	recDevice *device = joystick->hwdata;
+	recElement *element;
+	SInt32 value, range;
+	int i;
+
+	if (device->removed)  /* device was unplugged; ignore it. */
+	{
+		if (device->uncentered)
+		{
+			device->uncentered = 0;
+
+			/* Tell the app that everything is centered/unpressed... */
+			for (i = 0; i < device->axes; i++)
+				SDL_PrivateJoystickAxis(joystick, i, 0);
+
+			for (i = 0; i < device->buttons; i++)
+				SDL_PrivateJoystickButton(joystick, i, 0);
+
+			for (i = 0; i < device->hats; i++)
+				SDL_PrivateJoystickHat(joystick, i, SDL_HAT_CENTERED);
+		}
+
+		return;
+	}
+
+	element = device->firstAxis;
+	i = 0;
+	while (element)
+	{
+		value = HIDScaledCalibratedValue(device, element, -32768, 32767);
+		if ( value != joystick->axes[i] )
+			SDL_PrivateJoystickAxis(joystick, i, value);
+		element = element->pNext;
+		++i;
+	}
+	
+	element = device->firstButton;
+	i = 0;
+	while (element)
+	{
+		value = HIDGetElementValue(device, element);
+        if (value > 1)  /* handle pressure-sensitive buttons */
+            value = 1;
+		if ( value != joystick->buttons[i] )
+			SDL_PrivateJoystickButton(joystick, i, value);
+		element = element->pNext;
+		++i;
+	}
+	    
+	element = device->firstHat;
+	i = 0;
+	while (element)
+	{
+		Uint8 pos = 0;
+
+		range = (element->max - element->min + 1);
+		value = HIDGetElementValue(device, element) - element->min;
+		if (range == 4) /* 4 position hatswitch - scale up value */
+			value *= 2;
+		else if (range != 8) /* Neither a 4 nor 8 positions - fall back to default position (centered) */
+			value = -1;
+		switch(value)
+		{
+			case 0:
+				pos = SDL_HAT_UP;
+				break;
+			case 1:
+				pos = SDL_HAT_RIGHTUP;
+				break;
+			case 2:
+				pos = SDL_HAT_RIGHT;
+				break;
+			case 3:
+				pos = SDL_HAT_RIGHTDOWN;
+				break;
+			case 4:
+				pos = SDL_HAT_DOWN;
+				break;
+			case 5:
+				pos = SDL_HAT_LEFTDOWN;
+				break;
+			case 6:
+				pos = SDL_HAT_LEFT;
+				break;
+			case 7:
+				pos = SDL_HAT_LEFTUP;
+				break;
+			default:
+				/* Every other value is mapped to center. We do that because some
+				 * joysticks use 8 and some 15 for this value, and apparently
+				 * there are even more variants out there - so we try to be generous.
+				 */
+				pos = SDL_HAT_CENTERED;
+				break;
+		}
+		if ( pos != joystick->hats[i] )
+			SDL_PrivateJoystickHat(joystick, i, pos);
+		element = element->pNext;
+		++i;
+	}
+	
+	return;
+}
+
+/* Function to close a joystick after use */
+void SDL_SYS_JoystickClose(SDL_Joystick *joystick)
+{
+	/* Should we do anything here? */
+	return;
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void SDL_SYS_JoystickQuit(void)
+{
+	while (NULL != gpDeviceList)
+		gpDeviceList = HIDDisposeDevice (&gpDeviceList);
+}
+
+#endif /* SDL_JOYSTICK_IOKIT */