Merge lp:~brandontschaefer/libsdl/add-mir-support-v2 into lp:libsdl

[Brandon Schaefer]

Add support for Mir under libsdl1.2 for only i386/amd64 (no gles1/2 support in libsdl1.2).

Add support for Mir under libsdl1.2 for only i386/amd64 (no gles1/2 support in libsdl1.2).

This patch adds support for Software rendering and Opengl on the desktop for mir in sdl1.2.

*Note* This is written for the new libmir 0.13.1. This uses new event 2.0 and buffering system.

[lp:~brandontschaefer/libsdl/add-mir-support-v2]

53. By Brandon Schaefer on 2015-06-01

* I should not ignore key_repeat rather, if we are not a KEY_UP action
  assume its a KEY_DOWN event.

Unmerged revisions

53. By Brandon Schaefer on 2015-06-01

* I should not ignore key_repeat rather, if we are not a KEY_UP action
  assume its a KEY_DOWN event.

52. By Brandon Schaefer on 2015-06-01

* Make sure we depend on the version of mir this is written for

51. By Brandon Schaefer on 2015-05-29

* Add video driver backend support for Mir (i386/amd64)

50. By Steve Langasek on 2014-07-01

* Merge from Debian unstable, remaining changes:
  - Drop directfb support. This is the only package which still pulls the
    rather sizable directfb into a standard installation, and we never
    actually used/supported it anyway.
* Dropped changes, included in Debian:
  - Drop tslib support which is in universe.
  - debian/patches/sdl-check-for-SDL_VIDEO_X11_BACKINGSTORE.patch:
    Restore old backingstore behavior to prevent tearing.

49. By Steve Langasek on 2014-05-06

* Restore accidentally-clobbered changes from 1.2.15-8ubuntu2.

[ Timo Jyrinki ]
* debian/patches/sdl-check-for-SDL_VIDEO_X11_BACKINGSTORE.patch:
  - Restore old backingstore behavior to prevent tearing
    (LP: #1280665)

48. By Steve Langasek on 2014-05-01

* Merge from Debian unstable, remaining changes:
  - Drop directfb support. This is the only package which still pulls the
    rather sizable directfb into a standard installation, and we never
    actually used/supported it anyway.
  - Drop tslib support which is in universe.
* Dropped changes, included in Debian:
  - fix dh_autoreconf handling.

47. By Timo Jyrinki on 2014-04-19

* debian/patches/sdl-check-for-SDL_VIDEO_X11_BACKINGSTORE.patch:
  - Restore old backingstore behavior to prevent tearing
    (LP: #1280665)

46. By Steve Langasek on 2014-01-13

* Merge from Debian unstable, remaining changes:
  - Drop directfb support. This is the only package which still pulls the
    rather sizable directfb into a standard installation, and we never
    actually used/supported it anyway.
    --enable-video-directfb from confflags.
  - Drop tslib support which is in universe.
  - debian/rules, debian/patches/proper-autotools.patch: Fix wrong
    handling of dh_autoreconf that fails to ever re-libtoolize the
    package. Bypass calling autoheader, since configure.in isn't
    compatible with current version of autoheader.
* Dropped changes, merged in Debian:
  - drop the unused libsdl1.2debian-udeb package
  - Use dh_autotools-dev to update config.{sub,guess} for new ports.

45. By Steve Langasek on 2013-12-15

debian/rules, debian/patches/proper-autotools.patch: Fix wrong handling
of dh_autoreconf that fails to ever re-libtoolize the package. Bypass
calling autoheader, since configure.in isn't compatible with current
version of autoheader.

44. By Steve Langasek on 2013-12-16

releasing package libsdl1.2 version 1.2.15-5ubuntu3

=== added directory '.pc'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1 @@
+2

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2015-06-01 21:40:05 +0000
@@ -0,0 +1,7 @@
+x11_keytounicode.diff
+dont_propagate_lpthread.diff
+fix_build_joystick_freebsd.diff
+fix_window_resizing.diff
+fix_joystick_misc_axes.diff
+sdl-check-for-SDL_VIDEO_X11_BACKINGSTORE.patch
+mir-support.diff

=== added directory '.pc/dont_propagate_lpthread.diff'
=== added file '.pc/dont_propagate_lpthread.diff/sdl-config.in'
--- .pc/dont_propagate_lpthread.diff/sdl-config.in	1970-01-01 00:00:00 +0000
+++ .pc/dont_propagate_lpthread.diff/sdl-config.in	2015-06-01 21:40:05 +0000
@@ -0,0 +1,60 @@
+#!/bin/sh
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+exec_prefix_set=no
+libdir=@libdir@
+
+@ENABLE_STATIC_FALSE@usage="\
+@ENABLE_STATIC_FALSE@Usage: sdl-config [--prefix[=DIR]] [--exec-prefix[=DIR]] [--version] [--cflags] [--libs]"
+@ENABLE_STATIC_TRUE@usage="\
+@ENABLE_STATIC_TRUE@Usage: sdl-config [--prefix[=DIR]] [--exec-prefix[=DIR]] [--version] [--cflags] [--libs] [--static-libs]"
+
+if test $# -eq 0; then
+      echo "${usage}" 1>&2
+      exit 1
+fi
+
+while test $# -gt 0; do
+  case "$1" in
+  -*=*) optarg=`echo "$1" | LC_ALL="C" sed 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  case $1 in
+    --prefix=*)
+      prefix=$optarg
+      if test $exec_prefix_set = no ; then
+        exec_prefix=$optarg
+      fi
+      ;;
+    --prefix)
+      echo $prefix
+      ;;
+    --exec-prefix=*)
+      exec_prefix=$optarg
+      exec_prefix_set=yes
+      ;;
+    --exec-prefix)
+      echo $exec_prefix
+      ;;
+    --version)
+      echo @SDL_VERSION@
+      ;;
+    --cflags)
+      echo -I@includedir@/SDL @SDL_CFLAGS@
+      ;;
+@ENABLE_SHARED_TRUE@    --libs)
+@ENABLE_SHARED_TRUE@      echo -L@libdir@ @SDL_RLD_FLAGS@ @SDL_LIBS@
+@ENABLE_SHARED_TRUE@      ;;
+@ENABLE_STATIC_TRUE@@ENABLE_SHARED_TRUE@    --static-libs)
+@ENABLE_STATIC_TRUE@@ENABLE_SHARED_FALSE@    --libs|--static-libs)
+@ENABLE_STATIC_TRUE@      echo -L@libdir@ @SDL_RLD_FLAGS@ @SDL_STATIC_LIBS@
+@ENABLE_STATIC_TRUE@      ;;
+    *)
+      echo "${usage}" 1>&2
+      exit 1
+      ;;
+  esac
+  shift
+done

=== added file '.pc/dont_propagate_lpthread.diff/sdl.pc.in'
--- .pc/dont_propagate_lpthread.diff/sdl.pc.in	1970-01-01 00:00:00 +0000
+++ .pc/dont_propagate_lpthread.diff/sdl.pc.in	2015-06-01 21:40:05 +0000
@@ -0,0 +1,15 @@
+# sdl pkg-config source file
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: sdl
+Description: Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer.
+Version: @SDL_VERSION@
+Requires:
+Conflicts:
+Libs: -L${libdir} @SDL_RLD_FLAGS@ @SDL_LIBS@
+Libs.private: @SDL_STATIC_LIBS@
+Cflags: -I${includedir}/SDL @SDL_CFLAGS@

=== added directory '.pc/fix_build_joystick_freebsd.diff'
=== added directory '.pc/fix_build_joystick_freebsd.diff/src'
=== added directory '.pc/fix_build_joystick_freebsd.diff/src/joystick'
=== added directory '.pc/fix_build_joystick_freebsd.diff/src/joystick/bsd'
=== added file '.pc/fix_build_joystick_freebsd.diff/src/joystick/bsd/SDL_sysjoystick.c'
--- .pc/fix_build_joystick_freebsd.diff/src/joystick/bsd/SDL_sysjoystick.c	1970-01-01 00:00:00 +0000
+++ .pc/fix_build_joystick_freebsd.diff/src/joystick/bsd/SDL_sysjoystick.c	2015-06-01 21:40:05 +0000
@@ -0,0 +1,608 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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
+    [e-mail]
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_JOYSTICK_USBHID
+
+/*
+ * Joystick driver for the uhid(4) interface found in OpenBSD,
+ * NetBSD and FreeBSD.
+ *
+ * Maintainer: <vedge at csoft.org>
+ */
+
+#include <sys/param.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#ifndef __FreeBSD_kernel_version
+#define __FreeBSD_kernel_version __FreeBSD_version
+#endif
+
+#if defined(HAVE_USB_H)
+#include <usb.h>
+#endif
+#ifdef __DragonFly__
+#include <bus/usb/usb.h>
+#include <bus/usb/usbhid.h>
+#else
+#include <dev/usb/usb.h>
+#include <dev/usb/usbhid.h>
+#endif
+
+#if defined(HAVE_USBHID_H)
+#include <usbhid.h>
+#elif defined(HAVE_LIBUSB_H)
+#include <libusb.h>
+#elif defined(HAVE_LIBUSBHID_H)
+#include <libusbhid.h>
+#endif
+
+#if defined(__FREEBSD__) || defined(__FreeBSD_kernel__)
+#ifndef __DragonFly__
+#include <osreldate.h>
+#endif
+#if __FreeBSD_kernel_version > 800063
+#include <dev/usb/usb_ioctl.h>
+#endif
+#include <sys/joystick.h>
+#endif
+
+#if SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
+#include <machine/joystick.h>
+#endif
+
+#include "SDL_joystick.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+#define MAX_UHID_JOYS	4
+#define MAX_JOY_JOYS	2
+#define MAX_JOYS	(MAX_UHID_JOYS + MAX_JOY_JOYS)
+
+struct report {
+#if defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063)
+	struct	usb_gen_descriptor *buf;	/* Buffer */
+#else
+	struct	usb_ctl_report *buf;	/* Buffer */
+#endif
+	size_t	size;			/* Buffer size */
+	int	rid;			/* Report ID */
+	enum {
+		SREPORT_UNINIT,
+		SREPORT_CLEAN,
+		SREPORT_DIRTY
+	} status;
+};
+
+static struct {
+	int	uhid_report;
+	hid_kind_t kind;
+	const	char *name;
+} const repinfo[] = {
+	{ UHID_INPUT_REPORT,	hid_input,	"input" },
+	{ UHID_OUTPUT_REPORT,	hid_output,	"output" },
+	{ UHID_FEATURE_REPORT,	hid_feature,	"feature" }
+};
+
+enum {
+	REPORT_INPUT = 0,
+	REPORT_OUTPUT = 1,
+	REPORT_FEATURE = 2
+};
+
+enum {
+	JOYAXE_X,
+	JOYAXE_Y,
+	JOYAXE_Z,
+	JOYAXE_SLIDER,
+	JOYAXE_WHEEL,
+	JOYAXE_RX,
+	JOYAXE_RY,
+	JOYAXE_RZ,
+	JOYAXE_count
+};
+
+struct joystick_hwdata {
+	int	fd;
+	char	*path;
+	enum {
+		BSDJOY_UHID,	/* uhid(4) */
+		BSDJOY_JOY	/* joy(4) */
+	} type;
+	struct	report_desc *repdesc;
+	struct	report inreport;
+	int	axis_map[JOYAXE_count];	/* map present JOYAXE_* to 0,1,..*/
+	int	x;
+	int	y;
+	int	xmin;
+	int	ymin;
+	int	xmax;
+	int	ymax;
+};
+
+static char *joynames[MAX_JOYS];
+static char *joydevnames[MAX_JOYS];
+
+static int	report_alloc(struct report *, struct report_desc *, int);
+static void	report_free(struct report *);
+
+#if defined(USBHID_UCR_DATA) || defined(__FreeBSD_kernel__)
+#define REP_BUF_DATA(rep) ((rep)->buf->ucr_data)
+#elif (defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063))
+#define REP_BUF_DATA(rep) ((rep)->buf->ugd_data)
+#else
+#define REP_BUF_DATA(rep) ((rep)->buf->data)
+#endif
+
+int
+SDL_SYS_JoystickInit(void)
+{
+	char s[16];
+	int i, fd;
+
+	SDL_numjoysticks = 0;
+
+	SDL_memset(joynames, 0, sizeof(joynames));
+	SDL_memset(joydevnames, 0, sizeof(joydevnames));
+
+	for (i = 0; i < MAX_UHID_JOYS; i++) {
+		SDL_Joystick nj;
+
+		SDL_snprintf(s, SDL_arraysize(s), "/dev/uhid%d", i);
+
+		nj.index = SDL_numjoysticks;
+		joynames[nj.index] = strdup(s);
+
+		if (SDL_SYS_JoystickOpen(&nj) == 0) {
+			SDL_SYS_JoystickClose(&nj);
+			SDL_numjoysticks++;
+		} else {
+			SDL_free(joynames[nj.index]);
+			joynames[nj.index] = NULL;
+		}
+	}
+	for (i = 0; i < MAX_JOY_JOYS; i++) {
+		SDL_snprintf(s, SDL_arraysize(s), "/dev/joy%d", i);
+		fd = open(s, O_RDONLY);
+		if (fd != -1) {
+			joynames[SDL_numjoysticks++] = strdup(s);
+			close(fd);
+		}
+	}
+
+	/* Read the default USB HID usage table. */
+	hid_init(NULL);
+
+	return (SDL_numjoysticks);
+}
+
+const char *
+SDL_SYS_JoystickName(int index)
+{
+	if (joydevnames[index] != NULL) {
+		return (joydevnames[index]);
+	}
+	return (joynames[index]);
+}
+
+static int
+usage_to_joyaxe(unsigned usage)
+{
+    int joyaxe;
+    switch (usage) {
+    case HUG_X:
+	joyaxe = JOYAXE_X; break;
+    case HUG_Y:
+	joyaxe = JOYAXE_Y; break;
+    case HUG_Z:
+	joyaxe = JOYAXE_Z; break;
+    case HUG_SLIDER:
+	joyaxe = JOYAXE_SLIDER; break;
+    case HUG_WHEEL:
+	joyaxe = JOYAXE_WHEEL; break;
+    case HUG_RX:
+	joyaxe = JOYAXE_RX; break;
+    case HUG_RY:
+	joyaxe = JOYAXE_RY; break;
+    case HUG_RZ:
+	joyaxe = JOYAXE_RZ; break;
+    default:
+	joyaxe = -1;
+    }
+    return joyaxe;    
+}
+
+static unsigned
+hatval_to_sdl(Sint32 hatval)
+{
+    static const unsigned hat_dir_map[8] = {
+	SDL_HAT_UP, SDL_HAT_RIGHTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN, 
+	SDL_HAT_DOWN, SDL_HAT_LEFTDOWN, SDL_HAT_LEFT, SDL_HAT_LEFTUP
+    };
+    unsigned result;
+    if ((hatval & 7) == hatval) 
+	result = hat_dir_map[hatval];
+    else 
+	result = SDL_HAT_CENTERED;
+    return result;
+}
+
+
+int
+SDL_SYS_JoystickOpen(SDL_Joystick *joy)
+{
+	char *path = joynames[joy->index];
+	struct joystick_hwdata *hw;
+	struct hid_item hitem;
+	struct hid_data *hdata;
+	struct report *rep;
+	int fd;
+	int i;
+
+	fd = open(path, O_RDONLY);
+	if (fd == -1) {
+		SDL_SetError("%s: %s", path, strerror(errno));
+		return (-1);
+	}
+
+	hw = (struct joystick_hwdata *)SDL_malloc(sizeof(struct joystick_hwdata));
+	if (hw == NULL) {
+		SDL_OutOfMemory();
+		close(fd);
+		return (-1);
+	}
+	joy->hwdata = hw;
+	hw->fd = fd;
+	hw->path = strdup(path);
+	hw->x = 0;
+	hw->y = 0;
+	hw->xmin = 0xffff;
+	hw->ymin = 0xffff;
+	hw->xmax = 0;
+	hw->ymax = 0;
+	if (! SDL_strncmp(path, "/dev/joy", 8)) {
+		hw->type = BSDJOY_JOY;
+		joy->naxes = 2;
+		joy->nbuttons = 2;
+		joy->nhats = 0;
+		joy->nballs = 0;
+		joydevnames[joy->index] = strdup("Gameport joystick");
+		goto usbend;
+	} else {
+		hw->type = BSDJOY_UHID;
+	}
+
+	{
+	    int ax;
+	    for (ax = 0; ax < JOYAXE_count; ax++)
+		hw->axis_map[ax] = -1;
+	}
+	hw->repdesc = hid_get_report_desc(fd);
+	if (hw->repdesc == NULL) {
+		SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path,
+		    strerror(errno));
+		goto usberr;
+	}
+	rep = &hw->inreport;
+#if defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063) || defined(__FreeBSD_kernel__)
+       rep->rid = hid_get_report_id(fd);
+       if (rep->rid < 0) {
+#else
+	if (ioctl(fd, USB_GET_REPORT_ID, &rep->rid) < 0) {
+#endif
+		rep->rid = -1; /* XXX */
+	}
+	if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) {
+		goto usberr;
+	}
+	if (rep->size <= 0) {
+		SDL_SetError("%s: Input report descriptor has invalid length",
+		    hw->path);
+		goto usberr;
+	}
+
+#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111) || defined(__FreeBSD_kernel__)
+	hdata = hid_start_parse(hw->repdesc, 1 << hid_input, rep->rid);
+#else
+	hdata = hid_start_parse(hw->repdesc, 1 << hid_input);
+#endif
+	if (hdata == NULL) {
+		SDL_SetError("%s: Cannot start HID parser", hw->path);
+		goto usberr;
+	}
+	joy->naxes = 0;
+	joy->nbuttons = 0;
+	joy->nhats = 0;
+	joy->nballs = 0;
+	for (i=0; i<JOYAXE_count; i++)
+		hw->axis_map[i] = -1;
+
+	while (hid_get_item(hdata, &hitem) > 0) {
+		char *sp;
+		const char *s;
+
+		switch (hitem.kind) {
+		case hid_collection:
+			switch (HID_PAGE(hitem.usage)) {
+			case HUP_GENERIC_DESKTOP:
+				switch (HID_USAGE(hitem.usage)) {
+				case HUG_JOYSTICK:
+				case HUG_GAME_PAD:
+					s = hid_usage_in_page(hitem.usage);
+					sp = SDL_malloc(SDL_strlen(s) + 5);
+					SDL_snprintf(sp, SDL_strlen(s) + 5, "%s (%d)", s,
+					    joy->index);
+					joydevnames[joy->index] = sp;
+				}
+			}
+			break;
+		case hid_input:
+			switch (HID_PAGE(hitem.usage)) {
+			case HUP_GENERIC_DESKTOP: {
+			    unsigned usage = HID_USAGE(hitem.usage);
+			    int joyaxe = usage_to_joyaxe(usage);
+			    if (joyaxe >= 0) {
+				hw->axis_map[joyaxe] = 1;
+			    } else if (usage == HUG_HAT_SWITCH) {
+				joy->nhats++;
+			    }
+			    break;
+			}
+			case HUP_BUTTON:
+				joy->nbuttons++;
+				break;
+			default:
+				break;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	hid_end_parse(hdata);
+	for (i=0; i<JOYAXE_count; i++)
+		if (hw->axis_map[i] > 0)
+			hw->axis_map[i] = joy->naxes++;
+
+usbend:
+	/* The poll blocks the event thread. */
+	fcntl(fd, F_SETFL, O_NONBLOCK);
+
+	return (0);
+usberr:
+	close(hw->fd);
+	SDL_free(hw->path);
+	SDL_free(hw);
+	return (-1);
+}
+
+void
+SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
+{
+	struct hid_item hitem;
+	struct hid_data *hdata;
+	struct report *rep;
+	int nbutton, naxe = -1;
+	Sint32 v;
+
+#if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H || defined(__FreeBSD_kernel__)
+	struct joystick gameport;
+ 
+	if (joy->hwdata->type == BSDJOY_JOY) {
+		if (read(joy->hwdata->fd, &gameport, sizeof gameport) != sizeof gameport)
+			return;
+		if (abs(joy->hwdata->x - gameport.x) > 8) {
+			joy->hwdata->x = gameport.x;
+			if (joy->hwdata->x < joy->hwdata->xmin) {
+				joy->hwdata->xmin = joy->hwdata->x;
+			}
+			if (joy->hwdata->x > joy->hwdata->xmax) {
+				joy->hwdata->xmax = joy->hwdata->x;
+			}
+			if (joy->hwdata->xmin == joy->hwdata->xmax) {
+				joy->hwdata->xmin--;
+				joy->hwdata->xmax++;
+			}
+			v = (Sint32)joy->hwdata->x;
+			v -= (joy->hwdata->xmax + joy->hwdata->xmin + 1)/2;
+			v *= 32768/((joy->hwdata->xmax - joy->hwdata->xmin + 1)/2);
+			SDL_PrivateJoystickAxis(joy, 0, v);
+		}
+		if (abs(joy->hwdata->y - gameport.y) > 8) {
+			joy->hwdata->y = gameport.y;
+			if (joy->hwdata->y < joy->hwdata->ymin) {
+				joy->hwdata->ymin = joy->hwdata->y;
+			}
+			if (joy->hwdata->y > joy->hwdata->ymax) {
+				joy->hwdata->ymax = joy->hwdata->y;
+			}
+			if (joy->hwdata->ymin == joy->hwdata->ymax) {
+				joy->hwdata->ymin--;
+				joy->hwdata->ymax++;
+			}
+			v = (Sint32)joy->hwdata->y;
+			v -= (joy->hwdata->ymax + joy->hwdata->ymin + 1)/2;
+			v *= 32768/((joy->hwdata->ymax - joy->hwdata->ymin + 1)/2);
+			SDL_PrivateJoystickAxis(joy, 1, v);
+		}
+		if (gameport.b1 != joy->buttons[0]) {
+			SDL_PrivateJoystickButton(joy, 0, gameport.b1);
+		}
+		if (gameport.b2 != joy->buttons[1]) {
+			SDL_PrivateJoystickButton(joy, 1, gameport.b2);
+		}
+		return;
+	}
+#endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
+	
+	rep = &joy->hwdata->inreport;
+
+	if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) {
+		return;
+	}
+#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111) || defined(__FreeBSD_kernel__)
+	hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid);
+#else
+	hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
+#endif
+	if (hdata == NULL) {
+		fprintf(stderr, "%s: Cannot start HID parser\n",
+		    joy->hwdata->path);
+		return;
+	}
+
+	for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
+		switch (hitem.kind) {
+		case hid_input:
+			switch (HID_PAGE(hitem.usage)) {
+			case HUP_GENERIC_DESKTOP: {
+			    unsigned usage = HID_USAGE(hitem.usage);
+			    int joyaxe = usage_to_joyaxe(usage);
+			    if (joyaxe >= 0) {
+				naxe = joy->hwdata->axis_map[joyaxe];
+				/* scaleaxe */
+				v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
+							 &hitem);
+				v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2;
+				v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2);
+				if (v != joy->axes[naxe]) {
+				    SDL_PrivateJoystickAxis(joy, naxe, v);
+				}
+			    } else if (usage == HUG_HAT_SWITCH) {
+				v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
+							 &hitem);
+				SDL_PrivateJoystickHat(joy, 0,
+					hatval_to_sdl(v)-hitem.logical_minimum);
+			    }
+			    break;
+			}
+			case HUP_BUTTON:
+				v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
+				    &hitem);
+				if (joy->buttons[nbutton] != v) {
+					SDL_PrivateJoystickButton(joy,
+					    nbutton, v);
+				}
+				nbutton++;
+				break;
+			default:
+				continue;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	hid_end_parse(hdata);
+
+	return;
+}
+
+/* Function to close a joystick after use */
+void
+SDL_SYS_JoystickClose(SDL_Joystick *joy)
+{
+	if (SDL_strncmp(joy->hwdata->path, "/dev/joy", 8))	{
+		report_free(&joy->hwdata->inreport);
+		hid_dispose_report_desc(joy->hwdata->repdesc);
+	}
+	close(joy->hwdata->fd);
+	SDL_free(joy->hwdata->path);
+	SDL_free(joy->hwdata);
+
+	return;
+}
+
+void
+SDL_SYS_JoystickQuit(void)
+{
+	int i;
+
+	for (i = 0; i < MAX_JOYS; i++) {
+		if (joynames[i] != NULL)
+			SDL_free(joynames[i]);
+		if (joydevnames[i] != NULL)
+			SDL_free(joydevnames[i]);
+	}
+
+	return;
+}
+
+static int
+report_alloc(struct report *r, struct report_desc *rd, int repind)
+{
+	int len;
+
+#ifdef __DragonFly__
+	len = hid_report_size(rd, r->rid, repinfo[repind].kind);
+#elif __FREEBSD__
+# if (__FreeBSD_kernel_version >= 460000) || defined(__FreeBSD_kernel__)
+#  if (__FreeBSD_kernel_version <= 500111)
+	len = hid_report_size(rd, r->rid, repinfo[repind].kind);
+#  else
+	len = hid_report_size(rd, repinfo[repind].kind, r->rid);
+#  endif
+# else
+	len = hid_report_size(rd, repinfo[repind].kind, &r->rid);
+# endif
+#else
+# ifdef USBHID_NEW
+	len = hid_report_size(rd, repinfo[repind].kind, r->rid);
+# else
+	len = hid_report_size(rd, repinfo[repind].kind, &r->rid);
+# endif
+#endif
+
+	if (len < 0) {
+		SDL_SetError("Negative HID report size");
+		return (-1);
+	}
+	r->size = len;
+
+	if (r->size > 0) {
+		r->buf = SDL_malloc(sizeof(*r->buf) - sizeof(REP_BUF_DATA(r)) +
+		    r->size);
+		if (r->buf == NULL) {
+			SDL_OutOfMemory();
+			return (-1);
+		}
+	} else {
+		r->buf = NULL;
+	}
+
+	r->status = SREPORT_CLEAN;
+	return (0);
+}
+
+static void
+report_free(struct report *r)
+{
+	if (r->buf != NULL) {
+		SDL_free(r->buf);
+	}
+	r->status = SREPORT_UNINIT;
+}
+
+#endif /* SDL_JOYSTICK_USBHID */

=== added directory '.pc/fix_joystick_misc_axes.diff'
=== added directory '.pc/fix_joystick_misc_axes.diff/src'
=== added directory '.pc/fix_joystick_misc_axes.diff/src/joystick'
=== added directory '.pc/fix_joystick_misc_axes.diff/src/joystick/linux'
=== added file '.pc/fix_joystick_misc_axes.diff/src/joystick/linux/SDL_sysjoystick.c'
--- .pc/fix_joystick_misc_axes.diff/src/joystick/linux/SDL_sysjoystick.c	1970-01-01 00:00:00 +0000
+++ .pc/fix_joystick_misc_axes.diff/src/joystick/linux/SDL_sysjoystick.c	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1218 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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
+    [e-mail]
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_JOYSTICK_LINUX
+
+/* This is the system specific header for the SDL joystick API */
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <limits.h>		/* For the definition of PATH_MAX */
+#include <linux/joystick.h>
+#if SDL_INPUT_LINUXEV
+#include <linux/input.h>
+#endif
+
+#include "SDL_joystick.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+/* Special joystick configurations */
+static struct {
+	const char *name;
+	int naxes;
+	int nhats;
+	int nballs;
+} special_joysticks[] = {
+	{ "MadCatz Panther XL", 3, 2, 1 }, /* We don't handle rudder (axis 8) */
+	{ "SideWinder Precision Pro", 4, 1, 0 },
+	{ "SideWinder 3D Pro", 4, 1, 0 },
+	{ "Microsoft SideWinder 3D Pro", 4, 1, 0 },
+	{ "Microsoft SideWinder Precision Pro", 4, 1, 0 },
+	{ "Microsoft SideWinder Dual Strike USB version 1.0", 2, 1, 0 },
+	{ "WingMan Interceptor", 3, 3, 0 },
+	{ "WingMan Extreme Digital 3D", 4, 1, 0 },
+	{ "Microsoft SideWinder Precision 2 Joystick", 4, 1, 0 },
+	{ "Logitech Inc. WingMan Extreme Digital 3D", 4, 1, 0 },
+	{ "Saitek Saitek X45", 6, 1, 0 }
+};
+
+/* It looks like newer kernels have the logical mapping at the driver level */
+#define NO_LOGICAL_JOYSTICKS
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+/*
+   Some USB HIDs show up as a single joystick even though they actually
+   control 2 or more joysticks.
+*/
+/*
+   This code handles the MP-8800 (Quad) and MP-8866 (Dual), which can
+   be identified by their transparent blue design. It's quite trivial
+   to add other joysticks with similar quirky behavior.
+   -id
+*/
+
+struct joystick_logical_mapping {
+        int njoy;
+        int nthing;
+};
+
+/*
+   {logical joy, logical axis},
+   {logical joy, logical hat},
+   {logical joy, logical ball},
+   {logical joy, logical button}
+*/
+
+static struct joystick_logical_mapping mp88xx_1_logical_axismap[] = {
+   {0,0},{0,1},{0,2},{0,3},{0,4},{0,5}
+};
+static struct joystick_logical_mapping mp88xx_1_logical_buttonmap[] = {
+   {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11}
+};
+
+static struct joystick_logical_mapping mp88xx_2_logical_axismap[] = {
+   {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+   {1,2},{1,3},{0,4},{0,5},{1,4},{1,5}
+};
+static struct joystick_logical_mapping mp88xx_2_logical_buttonmap[] = {
+   {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+   {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}
+};
+
+static struct joystick_logical_mapping mp88xx_3_logical_axismap[] = {
+   {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+   {1,2},{1,3},{2,0},{2,1},{2,2},{2,3},
+   {0,4},{0,5},{1,4},{1,5},{2,4},{2,5}
+};
+static struct joystick_logical_mapping mp88xx_3_logical_buttonmap[] = {
+   {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+   {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11},
+   {2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}
+};
+
+static struct joystick_logical_mapping mp88xx_4_logical_axismap[] = {
+   {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+   {1,2},{1,3},{2,0},{2,1},{2,2},{2,3},
+   {3,0},{3,1},{3,2},{3,3},{0,4},{0,5},
+   {1,4},{1,5},{2,4},{2,5},{3,4},{3,5}
+};
+static struct joystick_logical_mapping mp88xx_4_logical_buttonmap[] = {
+   {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+   {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11},
+   {2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11},
+   {3,0},{3,1},{3,2},{3,3},{3,4},{3,5},{3,6},{3,7},{3,8},{3,9},{3,10},{3,11}
+};
+
+struct joystick_logical_layout {
+        int naxes;
+        int nhats;
+        int nballs;
+        int nbuttons;
+};
+
+static struct joystick_logical_layout mp88xx_1_logical_layout[] = {
+        {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_2_logical_layout[] = {
+        {6, 0, 0, 12},
+        {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_3_logical_layout[] = {
+        {6, 0, 0, 12},
+        {6, 0, 0, 12},
+        {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_4_logical_layout[] = {
+        {6, 0, 0, 12},
+        {6, 0, 0, 12},
+        {6, 0, 0, 12},
+        {6, 0, 0, 12}
+};
+
+/*
+   This array sets up a means of mapping a single physical joystick to
+   multiple logical joysticks. (djm)
+                                                                                
+   njoys
+        the number of logical joysticks
+                                                                                
+   layouts
+        an array of layout structures, one to describe each logical joystick
+                                                                                
+   axes, hats, balls, buttons
+        arrays that map a physical thingy to a logical thingy
+ */
+struct joystick_logicalmap {
+        const char *name;
+	int nbuttons;
+        int njoys;
+        struct joystick_logical_layout *layout;
+        struct joystick_logical_mapping *axismap;
+        struct joystick_logical_mapping *hatmap;
+        struct joystick_logical_mapping *ballmap;
+        struct joystick_logical_mapping *buttonmap;
+};
+
+static struct joystick_logicalmap joystick_logicalmap[] = {
+        {
+		"WiseGroup.,Ltd MP-8866 Dual USB Joypad",
+		12,
+		1,
+		mp88xx_1_logical_layout,
+        	mp88xx_1_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_1_logical_buttonmap
+	},
+        {
+		"WiseGroup.,Ltd MP-8866 Dual USB Joypad",
+		24,
+		2,
+		mp88xx_2_logical_layout,
+        	mp88xx_2_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_2_logical_buttonmap
+	},
+        {
+		"WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+		12,
+		1,
+		mp88xx_1_logical_layout,
+        	mp88xx_1_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_1_logical_buttonmap
+	},
+        {
+		"WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+		24,
+		2,
+		mp88xx_2_logical_layout,
+        	mp88xx_2_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_2_logical_buttonmap
+	},
+        {
+		"WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+		36,
+		3,
+		mp88xx_3_logical_layout,
+        	mp88xx_3_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_3_logical_buttonmap
+	},
+        {
+		"WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+		48,
+		4,
+		mp88xx_4_logical_layout,
+        	mp88xx_4_logical_axismap,
+		NULL,
+		NULL,
+        	mp88xx_4_logical_buttonmap
+	}
+};
+
+/* find the head of a linked list, given a point in it
+ */
+#define SDL_joylist_head(i, start)\
+        for(i = start; SDL_joylist[i].fname == NULL;) i = SDL_joylist[i].prev;
+
+#define SDL_logical_joydecl(d) d
+
+
+#else
+
+#define SDL_logical_joydecl(d)
+
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+/* The maximum number of joysticks we'll detect */
+#define MAX_JOYSTICKS	32
+
+/* A list of available joysticks */
+static struct
+{
+        char* fname;
+#ifndef NO_LOGICAL_JOYSTICKS
+        SDL_Joystick* joy;
+        struct joystick_logicalmap* map;
+        int prev;
+        int next;
+        int logicalno;
+#endif /* USE_LOGICAL_JOYSTICKS */
+} SDL_joylist[MAX_JOYSTICKS];
+
+
+/* The private structure used to keep track of a joystick */
+struct joystick_hwdata {
+	int fd;
+	/* The current linux joystick driver maps hats to two axes */
+	struct hwdata_hat {
+		int axis[2];
+	} *hats;
+	/* The current linux joystick driver maps balls to two axes */
+	struct hwdata_ball {
+		int axis[2];
+	} *balls;
+
+	/* Support for the Linux 2.4 unified input interface */
+#if SDL_INPUT_LINUXEV
+	SDL_bool is_hid;
+	Uint8 key_map[KEY_MAX-BTN_MISC];
+	Uint8 abs_map[ABS_MAX];
+	struct axis_correct {
+		int used;
+		int coef[3];
+	} abs_correct[ABS_MAX];
+#endif
+};
+
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+static int CountLogicalJoysticks(int max)
+{
+   register int i, j, k, ret, prev;
+   const char* name;
+   int nbuttons, fd;
+   unsigned char n;
+
+   ret = 0;
+
+   for(i = 0; i < max; i++) {
+      name = SDL_SYS_JoystickName(i);
+	
+      fd = open(SDL_joylist[i].fname, O_RDONLY, 0);
+      if ( fd >= 0 ) {
+	 if ( ioctl(fd, JSIOCGBUTTONS, &n) < 0 ) {
+	    nbuttons = -1;
+	 } else {
+            nbuttons = n;
+	 }
+	 close(fd);
+      }
+      else {
+	 nbuttons=-1;
+      }
+
+      if (name) {
+         for(j = 0; j < SDL_arraysize(joystick_logicalmap); j++) {
+            if (!SDL_strcmp(name, joystick_logicalmap[j].name) && (nbuttons==-1 || nbuttons==joystick_logicalmap[j].nbuttons)) {
+               prev = i;
+               SDL_joylist[prev].map = &(joystick_logicalmap[j]);
+
+               for(k = 1; k < joystick_logicalmap[j].njoys; k++) {
+                  SDL_joylist[prev].next = max + ret;
+                  SDL_joylist[max+ret].prev = prev;
+		  
+                  prev = max + ret;
+                  SDL_joylist[prev].logicalno = k;
+                  SDL_joylist[prev].map = &(joystick_logicalmap[j]);
+                  ret++;
+               }
+
+               break;
+            }
+         }
+      }
+   }
+
+   return ret;
+}
+
+static void LogicalSuffix(int logicalno, char* namebuf, int len)
+{
+   register int slen;
+   const static char suffixs[] =
+      "01020304050607080910111213141516171819"
+      "20212223242526272829303132";
+   const char* suffix;
+   slen = SDL_strlen(namebuf);
+   suffix = NULL;
+
+   if (logicalno*2<sizeof(suffixs))
+      suffix = suffixs + (logicalno*2);
+
+   if (slen + 4 < len && suffix) {
+      namebuf[slen++] = ' ';
+      namebuf[slen++] = '#';
+      namebuf[slen++] = suffix[0];
+      namebuf[slen++] = suffix[1];
+      namebuf[slen++] = 0;
+   }
+}
+
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+#if SDL_INPUT_LINUXEV
+#define test_bit(nr, addr) \
+	(((1UL << ((nr) % (sizeof(long) * 8))) & ((addr)[(nr) / (sizeof(long) * 8)])) != 0)
+#define NBITS(x) ((((x)-1)/(sizeof(long) * 8))+1)
+
+static int EV_IsJoystick(int fd)
+{
+	unsigned long evbit[NBITS(EV_MAX)] = { 0 };
+	unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
+	unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
+
+	if ( (ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
+	     (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
+	     (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0) ) {
+		return(0);
+	}
+	if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
+	      test_bit(ABS_X, absbit) && test_bit(ABS_Y, absbit) &&
+	     (test_bit(BTN_TRIGGER, keybit) || test_bit(BTN_A, keybit) || test_bit(BTN_1, keybit)))) return 0;
+	return(1);
+}
+
+#endif /* SDL_INPUT_LINUXEV */
+
+/* Function to scan the system for joysticks */
+int SDL_SYS_JoystickInit(void)
+{
+	/* The base path of the joystick devices */
+	const char *joydev_pattern[] = {
+#if SDL_INPUT_LINUXEV
+		"/dev/input/event%d",
+#endif
+		"/dev/input/js%d",
+		"/dev/js%d"
+	};
+	int numjoysticks;
+	int i, j;
+	int fd;
+	char path[PATH_MAX];
+	dev_t dev_nums[MAX_JOYSTICKS];  /* major/minor device numbers */
+	struct stat sb;
+	int n, duplicate;
+
+	numjoysticks = 0;
+
+	/* First see if the user specified one or more joysticks to use */
+	if ( SDL_getenv("SDL_JOYSTICK_DEVICE") != NULL ) {
+		char *envcopy, *envpath, *delim;
+		envcopy = SDL_strdup(SDL_getenv("SDL_JOYSTICK_DEVICE"));
+		envpath = envcopy;
+		while ( envpath != NULL ) {
+			delim = SDL_strchr(envpath, ':');
+			if ( delim != NULL ) {
+				*delim++ = '\0';
+			}
+			if ( stat(envpath, &sb) == 0 ) {
+				fd = open(envpath, O_RDONLY, 0);
+				if ( fd >= 0 ) {
+					/* Assume the user knows what they're doing. */
+					SDL_joylist[numjoysticks].fname = SDL_strdup(envpath);
+					if ( SDL_joylist[numjoysticks].fname ) {
+						dev_nums[numjoysticks] = sb.st_rdev;
+						++numjoysticks;
+					}
+					close(fd);
+				}
+			}
+			envpath = delim;
+		}
+		SDL_free(envcopy);
+	}
+
+	for ( i=0; i<SDL_arraysize(joydev_pattern); ++i ) {
+		for ( j=0; j < MAX_JOYSTICKS; ++j ) {
+			SDL_snprintf(path, SDL_arraysize(path), joydev_pattern[i], j);
+
+			/* rcg06302000 replaced access(F_OK) call with stat().
+			 * stat() will fail if the file doesn't exist, so it's
+			 * equivalent behaviour.
+			 */
+			if ( stat(path, &sb) == 0 ) {
+				/* Check to make sure it's not already in list.
+				 * This happens when we see a stick via symlink.
+				 */
+				duplicate = 0;
+				for (n=0; (n<numjoysticks) && !duplicate; ++n) {
+					if ( sb.st_rdev == dev_nums[n] ) {
+						duplicate = 1;
+					}
+				}
+				if (duplicate) {
+					continue;
+				}
+
+				fd = open(path, O_RDONLY, 0);
+				if ( fd < 0 ) {
+					continue;
+				}
+#if SDL_INPUT_LINUXEV
+#ifdef DEBUG_INPUT_EVENTS
+				printf("Checking %s\n", path);
+#endif
+				if ( (i == 0) && ! EV_IsJoystick(fd) ) {
+					close(fd);
+					continue;
+				}
+#endif
+				close(fd);
+
+				/* We're fine, add this joystick */
+				SDL_joylist[numjoysticks].fname = SDL_strdup(path);
+				if ( SDL_joylist[numjoysticks].fname ) {
+					dev_nums[numjoysticks] = sb.st_rdev;
+					++numjoysticks;
+				}
+			}
+		}
+
+#if SDL_INPUT_LINUXEV
+		/* This is a special case...
+		   If the event devices are valid then the joystick devices
+		   will be duplicates but without extra information about their
+		   hats or balls. Unfortunately, the event devices can't
+		   currently be calibrated, so it's a win-lose situation.
+		   So : /dev/input/eventX = /dev/input/jsY = /dev/jsY
+		*/
+		if ( (i == 0) && (numjoysticks > 0) )
+			break;
+#endif
+	}
+#ifndef NO_LOGICAL_JOYSTICKS
+	numjoysticks += CountLogicalJoysticks(numjoysticks);
+#endif
+
+	return(numjoysticks);
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *SDL_SYS_JoystickName(int index)
+{
+	int fd;
+	static char namebuf[128];
+	char *name;
+	SDL_logical_joydecl(int oindex = index);
+
+#ifndef NO_LOGICAL_JOYSTICKS
+	SDL_joylist_head(index, index);
+#endif
+	name = NULL;
+	fd = open(SDL_joylist[index].fname, O_RDONLY, 0);
+	if ( fd >= 0 ) {
+		if ( 
+#if SDL_INPUT_LINUXEV
+		     (ioctl(fd, EVIOCGNAME(sizeof(namebuf)), namebuf) <= 0) &&
+#endif
+		     (ioctl(fd, JSIOCGNAME(sizeof(namebuf)), namebuf) <= 0) ) {
+			name = SDL_joylist[index].fname;
+		} else {
+			name = namebuf;
+		}
+		close(fd);
+
+
+#ifndef NO_LOGICAL_JOYSTICKS
+		if (SDL_joylist[oindex].prev || SDL_joylist[oindex].next || index!=oindex)
+		{
+       		   LogicalSuffix(SDL_joylist[oindex].logicalno, namebuf, 128);
+		}
+#endif
+	}
+	return name;
+}
+
+static int allocate_hatdata(SDL_Joystick *joystick)
+{
+	int i;
+
+	joystick->hwdata->hats = (struct hwdata_hat *)SDL_malloc(
+		joystick->nhats * sizeof(struct hwdata_hat));
+	if ( joystick->hwdata->hats == NULL ) {
+		return(-1);
+	}
+	for ( i=0; i<joystick->nhats; ++i ) {
+		joystick->hwdata->hats[i].axis[0] = 1;
+		joystick->hwdata->hats[i].axis[1] = 1;
+	}
+	return(0);
+}
+
+static int allocate_balldata(SDL_Joystick *joystick)
+{
+	int i;
+
+	joystick->hwdata->balls = (struct hwdata_ball *)SDL_malloc(
+		joystick->nballs * sizeof(struct hwdata_ball));
+	if ( joystick->hwdata->balls == NULL ) {
+		return(-1);
+	}
+	for ( i=0; i<joystick->nballs; ++i ) {
+		joystick->hwdata->balls[i].axis[0] = 0;
+		joystick->hwdata->balls[i].axis[1] = 0;
+	}
+	return(0);
+}
+
+static SDL_bool JS_ConfigJoystick(SDL_Joystick *joystick, int fd)
+{
+	SDL_bool handled;
+	unsigned char n;
+	int tmp_naxes, tmp_nhats, tmp_nballs;
+	const char *name;
+	char *env, env_name[128];
+	int i;
+
+	handled = SDL_FALSE;
+
+	/* Default joystick device settings */
+	if ( ioctl(fd, JSIOCGAXES, &n) < 0 ) {
+		joystick->naxes = 2;
+	} else {
+		joystick->naxes = n;
+	}
+	if ( ioctl(fd, JSIOCGBUTTONS, &n) < 0 ) {
+		joystick->nbuttons = 2;
+	} else {
+		joystick->nbuttons = n;
+	}
+
+	name = SDL_SYS_JoystickName(joystick->index);
+
+	/* Generic analog joystick support */
+	if ( SDL_strstr(name, "Analog") == name && SDL_strstr(name, "-hat") ) {
+		if ( SDL_sscanf(name,"Analog %d-axis %*d-button %d-hat",
+			&tmp_naxes, &tmp_nhats) == 2 ) {
+
+			joystick->naxes = tmp_naxes;
+			joystick->nhats = tmp_nhats;
+
+			handled = SDL_TRUE;
+		}
+	}
+
+	/* Special joystick support */
+	for ( i=0; i < SDL_arraysize(special_joysticks); ++i ) {
+		if ( SDL_strcmp(name, special_joysticks[i].name) == 0 ) {
+
+			joystick->naxes = special_joysticks[i].naxes;
+			joystick->nhats = special_joysticks[i].nhats;
+			joystick->nballs = special_joysticks[i].nballs;
+
+			handled = SDL_TRUE;
+			break;
+		}
+	}
+
+	/* User environment joystick support */
+	if ( (env = SDL_getenv("SDL_LINUX_JOYSTICK")) ) {
+		*env_name = '\0';
+		if ( *env == '\'' && SDL_sscanf(env, "'%[^']s'", env_name) == 1 )
+			env += SDL_strlen(env_name)+2;
+		else if ( SDL_sscanf(env, "%s", env_name) == 1 )
+			env += SDL_strlen(env_name);
+
+		if ( SDL_strcmp(name, env_name) == 0 ) {
+
+			if ( SDL_sscanf(env, "%d %d %d", &tmp_naxes, &tmp_nhats,
+				&tmp_nballs) == 3 ) {
+
+				joystick->naxes = tmp_naxes;
+				joystick->nhats = tmp_nhats;
+				joystick->nballs = tmp_nballs;
+
+				handled = SDL_TRUE;
+			}
+		}
+	}
+
+	/* Remap hats and balls */
+	if (handled) {
+		if ( joystick->nhats > 0 ) {
+			if ( allocate_hatdata(joystick) < 0 ) {
+				joystick->nhats = 0;
+			}
+		}
+		if ( joystick->nballs > 0 ) {
+			if ( allocate_balldata(joystick) < 0 ) {
+				joystick->nballs = 0;
+			}
+		}
+	}
+
+	return(handled);
+}
+
+#if SDL_INPUT_LINUXEV
+
+static SDL_bool EV_ConfigJoystick(SDL_Joystick *joystick, int fd)
+{
+	int i, t;
+	unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
+	unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
+	unsigned long relbit[NBITS(REL_MAX)] = { 0 };
+
+	/* See if this device uses the new unified event API */
+	if ( (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) >= 0) &&
+	     (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) >= 0) &&
+	     (ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relbit)), relbit) >= 0) ) {
+		joystick->hwdata->is_hid = SDL_TRUE;
+
+		/* Get the number of buttons, axes, and other thingamajigs */
+		for ( i=BTN_JOYSTICK; i < KEY_MAX; ++i ) {
+			if ( test_bit(i, keybit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+				printf("Joystick has button: 0x%x\n", i);
+#endif
+				joystick->hwdata->key_map[i-BTN_MISC] =
+						joystick->nbuttons;
+				++joystick->nbuttons;
+			}
+		}
+		for ( i=BTN_MISC; i < BTN_JOYSTICK; ++i ) {
+			if ( test_bit(i, keybit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+				printf("Joystick has button: 0x%x\n", i);
+#endif
+				joystick->hwdata->key_map[i-BTN_MISC] =
+						joystick->nbuttons;
+				++joystick->nbuttons;
+			}
+		}
+		for ( i=0; i<ABS_MISC; ++i ) {
+			/* Skip hats */
+			if ( i == ABS_HAT0X ) {
+				i = ABS_HAT3Y;
+				continue;
+			}
+			if ( test_bit(i, absbit) ) {
+				struct input_absinfo absinfo;
+
+				if ( ioctl(fd, EVIOCGABS(i), &absinfo) < 0 )
+					continue;
+#ifdef DEBUG_INPUT_EVENTS
+				printf("Joystick has absolute axis: %x\n", i);
+				printf("Values = { %d, %d, %d, %d, %d }\n",
+					absinfo.value, absinfo.minimum,
+					absinfo.maximum, absinfo.fuzz, absinfo.flat);
+#endif /* DEBUG_INPUT_EVENTS */
+				joystick->hwdata->abs_map[i] = joystick->naxes;
+				if ( absinfo.minimum == absinfo.maximum ) {
+				    joystick->hwdata->abs_correct[i].used = 0;
+				} else {
+				    joystick->hwdata->abs_correct[i].used = 1;
+				    joystick->hwdata->abs_correct[i].coef[0] =
+					(absinfo.maximum + absinfo.minimum) / 2 - absinfo.flat;
+				    joystick->hwdata->abs_correct[i].coef[1] =
+					(absinfo.maximum + absinfo.minimum) / 2 + absinfo.flat;
+				    t = ((absinfo.maximum - absinfo.minimum) / 2 - 2 * absinfo.flat);
+				    if ( t != 0 ) {
+					joystick->hwdata->abs_correct[i].coef[2] = (1 << 29) / t;
+				    } else {
+					joystick->hwdata->abs_correct[i].coef[2] = 0;
+				    }
+				}
+				++joystick->naxes;
+			}
+		}
+		for ( i=ABS_HAT0X; i <= ABS_HAT3Y; i += 2 ) {
+			if ( test_bit(i, absbit) || test_bit(i+1, absbit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+				printf("Joystick has hat %d\n",(i-ABS_HAT0X)/2);
+#endif
+				++joystick->nhats;
+			}
+		}
+		if ( test_bit(REL_X, relbit) || test_bit(REL_Y, relbit) ) {
+			++joystick->nballs;
+		}
+
+		/* Allocate data to keep track of these thingamajigs */
+		if ( joystick->nhats > 0 ) {
+			if ( allocate_hatdata(joystick) < 0 ) {
+				joystick->nhats = 0;
+			}
+		}
+		if ( joystick->nballs > 0 ) {
+			if ( allocate_balldata(joystick) < 0 ) {
+				joystick->nballs = 0;
+			}
+		}
+	}
+	return(joystick->hwdata->is_hid);
+}
+
+#endif /* SDL_INPUT_LINUXEV */
+
+#ifndef NO_LOGICAL_JOYSTICKS
+static void ConfigLogicalJoystick(SDL_Joystick *joystick)
+{
+        struct joystick_logical_layout* layout;
+                                                                                
+        layout = SDL_joylist[joystick->index].map->layout +
+                SDL_joylist[joystick->index].logicalno;
+                                                                                
+        joystick->nbuttons = layout->nbuttons;
+        joystick->nhats = layout->nhats;
+        joystick->naxes = layout->naxes;
+        joystick->nballs = layout->nballs;
+}
+#endif
+
+
+/* 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)
+{
+	int fd;
+	SDL_logical_joydecl(int realindex);
+	SDL_logical_joydecl(SDL_Joystick *realjoy = NULL);
+
+	/* Open the joystick and set the joystick file descriptor */
+#ifndef NO_LOGICAL_JOYSTICKS
+	if (SDL_joylist[joystick->index].fname == NULL) {
+		SDL_joylist_head(realindex, joystick->index);
+		realjoy = SDL_JoystickOpen(realindex);
+
+		if (realjoy == NULL)
+			return(-1);
+                                                                                
+		fd = realjoy->hwdata->fd;
+
+	} else {
+		fd = open(SDL_joylist[joystick->index].fname, O_RDONLY, 0);
+	}
+	SDL_joylist[joystick->index].joy = joystick;
+#else
+	fd = open(SDL_joylist[joystick->index].fname, O_RDONLY, 0);
+#endif
+
+	if ( fd < 0 ) {
+		SDL_SetError("Unable to open %s\n",
+		             SDL_joylist[joystick->index]);
+		return(-1);
+	}
+	joystick->hwdata = (struct joystick_hwdata *)
+	                   SDL_malloc(sizeof(*joystick->hwdata));
+	if ( joystick->hwdata == NULL ) {
+		SDL_OutOfMemory();
+		close(fd);
+		return(-1);
+	}
+	SDL_memset(joystick->hwdata, 0, sizeof(*joystick->hwdata));
+	joystick->hwdata->fd = fd;
+
+	/* Set the joystick to non-blocking read mode */
+	fcntl(fd, F_SETFL, O_NONBLOCK);
+
+	/* Get the number of buttons and axes on the joystick */
+#ifndef NO_LOGICAL_JOYSTICKS
+	if (realjoy)
+		ConfigLogicalJoystick(joystick);
+	else
+#endif
+#if SDL_INPUT_LINUXEV
+	if ( ! EV_ConfigJoystick(joystick, fd) )
+#endif
+		JS_ConfigJoystick(joystick, fd);
+
+	return(0);
+}
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+static SDL_Joystick* FindLogicalJoystick(
+   SDL_Joystick *joystick, struct joystick_logical_mapping* v)
+{
+        SDL_Joystick *logicaljoy;
+        register int i;
+
+        i = joystick->index;
+        logicaljoy = NULL;
+
+        /* get the fake joystick that will receive the event
+         */
+        for(;;) {
+
+           if (SDL_joylist[i].logicalno == v->njoy) {
+              logicaljoy = SDL_joylist[i].joy;
+              break;
+           }
+
+           if (SDL_joylist[i].next == 0)
+              break;
+
+           i = SDL_joylist[i].next;
+
+        }
+
+        return logicaljoy;
+}
+
+static int LogicalJoystickButton(
+   SDL_Joystick *joystick, Uint8 button, Uint8 state){
+        struct joystick_logical_mapping* buttons;
+        SDL_Joystick *logicaljoy = NULL;
+
+        /* if there's no map then this is just a regular joystick
+         */
+        if (SDL_joylist[joystick->index].map == NULL)
+           return 0;
+
+        /* get the logical joystick that will receive the event
+         */
+        buttons = SDL_joylist[joystick->index].map->buttonmap+button;
+        logicaljoy = FindLogicalJoystick(joystick, buttons);
+
+        if (logicaljoy == NULL)
+           return 1;
+
+        SDL_PrivateJoystickButton(logicaljoy, buttons->nthing, state);
+
+        return 1;
+}
+
+static int LogicalJoystickAxis(
+	SDL_Joystick *joystick, Uint8 axis, Sint16 value)
+{
+        struct joystick_logical_mapping* axes;
+        SDL_Joystick *logicaljoy = NULL;
+
+        /* if there's no map then this is just a regular joystick
+         */
+        if (SDL_joylist[joystick->index].map == NULL)
+           return 0;
+
+        /* get the logical joystick that will receive the event
+         */
+        axes = SDL_joylist[joystick->index].map->axismap+axis;
+        logicaljoy = FindLogicalJoystick(joystick, axes);
+
+        if (logicaljoy == NULL)
+           return 1;
+
+        SDL_PrivateJoystickAxis(logicaljoy, axes->nthing, value);
+
+        return 1;
+}
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+static __inline__
+void HandleHat(SDL_Joystick *stick, Uint8 hat, int axis, int value)
+{
+	struct hwdata_hat *the_hat;
+	const Uint8 position_map[3][3] = {
+		{ SDL_HAT_LEFTUP, SDL_HAT_UP, SDL_HAT_RIGHTUP },
+		{ SDL_HAT_LEFT, SDL_HAT_CENTERED, SDL_HAT_RIGHT },
+		{ SDL_HAT_LEFTDOWN, SDL_HAT_DOWN, SDL_HAT_RIGHTDOWN }
+	};
+	SDL_logical_joydecl(SDL_Joystick *logicaljoy = NULL);
+	SDL_logical_joydecl(struct joystick_logical_mapping* hats = NULL);
+
+	if (stick->nhats <= hat) {
+		return;  /* whoops, that shouldn't happen! */
+	}
+
+	the_hat = &stick->hwdata->hats[hat];
+	if ( value < 0 ) {
+		value = 0;
+	} else
+	if ( value == 0 ) {
+		value = 1;
+	} else
+	if ( value > 0 ) {
+		value = 2;
+	}
+	if ( value != the_hat->axis[axis] ) {
+		the_hat->axis[axis] = value;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+		/* if there's no map then this is just a regular joystick
+		*/
+		if (SDL_joylist[stick->index].map != NULL) {
+
+			/* get the fake joystick that will receive the event
+			*/
+			hats = SDL_joylist[stick->index].map->hatmap+hat;
+			logicaljoy = FindLogicalJoystick(stick, hats);
+		}
+
+		if (logicaljoy) {
+			stick = logicaljoy;
+			hat = hats->nthing;
+		}
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+		SDL_PrivateJoystickHat(stick, hat,
+			position_map[the_hat->axis[1]][the_hat->axis[0]]);
+	}
+}
+
+static __inline__
+void HandleBall(SDL_Joystick *stick, Uint8 ball, int axis, int value)
+{
+	if ((stick->nballs <= ball) || (axis >= 2)) {
+		return;  /* whoops, that shouldn't happen! */
+	}
+	stick->hwdata->balls[ball].axis[axis] += value;
+}
+
+/* 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.
+ */
+static __inline__ void JS_HandleEvents(SDL_Joystick *joystick)
+{
+	struct js_event events[32];
+	int i, len;
+	Uint8 other_axis;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+	if (SDL_joylist[joystick->index].fname == NULL) {
+		SDL_joylist_head(i, joystick->index);
+		JS_HandleEvents(SDL_joylist[i].joy);
+		return;
+	}
+#endif
+
+	while ((len=read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
+		len /= sizeof(events[0]);
+		for ( i=0; i<len; ++i ) {
+			switch (events[i].type & ~JS_EVENT_INIT) {
+			    case JS_EVENT_AXIS:
+				if ( events[i].number < joystick->naxes ) {
+#ifndef NO_LOGICAL_JOYSTICKS
+					if (!LogicalJoystickAxis(joystick,
+				           events[i].number, events[i].value))
+#endif
+					SDL_PrivateJoystickAxis(joystick,
+				           events[i].number, events[i].value);
+					break;
+				}
+				events[i].number -= joystick->naxes;
+				other_axis = (events[i].number / 2);
+				if ( other_axis < joystick->nhats ) {
+					HandleHat(joystick, other_axis,
+						events[i].number%2,
+						events[i].value);
+					break;
+				}
+				events[i].number -= joystick->nhats*2;
+				other_axis = (events[i].number / 2);
+				if ( other_axis < joystick->nballs ) {
+					HandleBall(joystick, other_axis,
+						events[i].number%2,
+						events[i].value);
+					break;
+				}
+				break;
+			    case JS_EVENT_BUTTON:
+#ifndef NO_LOGICAL_JOYSTICKS
+				if (!LogicalJoystickButton(joystick,
+				           events[i].number, events[i].value))
+#endif
+				SDL_PrivateJoystickButton(joystick,
+				           events[i].number, events[i].value);
+				break;
+			    default:
+				/* ?? */
+				break;
+			}
+		}
+	}
+}
+#if SDL_INPUT_LINUXEV
+static __inline__ int EV_AxisCorrect(SDL_Joystick *joystick, int which, int value)
+{
+	struct axis_correct *correct;
+
+	correct = &joystick->hwdata->abs_correct[which];
+	if ( correct->used ) {
+		if ( value > correct->coef[0] ) {
+			if ( value < correct->coef[1] ) {
+				return 0;
+			}
+			value -= correct->coef[1];
+		} else {
+			value -= correct->coef[0];
+		}
+		value *= correct->coef[2];
+		value >>= 14;
+	}
+
+	/* Clamp and return */
+	if ( value < -32768 ) return -32768;
+	if ( value >  32767 ) return  32767;
+
+	return value;
+}
+
+static __inline__ void EV_HandleEvents(SDL_Joystick *joystick)
+{
+	struct input_event events[32];
+	int i, len;
+	int code;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+	if (SDL_joylist[joystick->index].fname == NULL) {
+		SDL_joylist_head(i, joystick->index);
+		return EV_HandleEvents(SDL_joylist[i].joy);
+	}
+#endif
+
+	while ((len=read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
+		len /= sizeof(events[0]);
+		for ( i=0; i<len; ++i ) {
+			code = events[i].code;
+			switch (events[i].type) {
+			    case EV_KEY:
+				if ( code >= BTN_MISC ) {
+					code -= BTN_MISC;
+#ifndef NO_LOGICAL_JOYSTICKS
+					if (!LogicalJoystickButton(joystick,
+				           joystick->hwdata->key_map[code],
+					   events[i].value))
+#endif
+					SDL_PrivateJoystickButton(joystick,
+				           joystick->hwdata->key_map[code],
+					   events[i].value);
+				}
+				break;
+			    case EV_ABS:
+				switch (code) {
+				    case ABS_HAT0X:
+				    case ABS_HAT0Y:
+				    case ABS_HAT1X:
+				    case ABS_HAT1Y:
+				    case ABS_HAT2X:
+				    case ABS_HAT2Y:
+				    case ABS_HAT3X:
+				    case ABS_HAT3Y:
+					code -= ABS_HAT0X;
+					HandleHat(joystick, code/2, code%2,
+							events[i].value);
+					break;
+				    default:
+					events[i].value = EV_AxisCorrect(joystick, code, events[i].value);
+#ifndef NO_LOGICAL_JOYSTICKS
+					if (!LogicalJoystickAxis(joystick,
+				           joystick->hwdata->abs_map[code],
+					   events[i].value))
+#endif
+					SDL_PrivateJoystickAxis(joystick,
+				           joystick->hwdata->abs_map[code],
+					   events[i].value);
+					break;
+				}
+				break;
+			    case EV_REL:
+				switch (code) {
+				    case REL_X:
+				    case REL_Y:
+					code -= REL_X;
+					HandleBall(joystick, code/2, code%2,
+							events[i].value);
+					break;
+				    default:
+					break;
+				}
+				break;
+			    default:
+				break;
+			}
+		}
+	}
+}
+#endif /* SDL_INPUT_LINUXEV */
+
+void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
+{
+	int i;
+	
+#if SDL_INPUT_LINUXEV
+	if ( joystick->hwdata->is_hid )
+		EV_HandleEvents(joystick);
+	else
+#endif
+		JS_HandleEvents(joystick);
+
+	/* Deliver ball motion updates */
+	for ( i=0; i<joystick->nballs; ++i ) {
+		int xrel, yrel;
+
+		xrel = joystick->hwdata->balls[i].axis[0];
+		yrel = joystick->hwdata->balls[i].axis[1];
+		if ( xrel || yrel ) {
+			joystick->hwdata->balls[i].axis[0] = 0;
+			joystick->hwdata->balls[i].axis[1] = 0;
+			SDL_PrivateJoystickBall(joystick, (Uint8)i, xrel, yrel);
+		}
+	}
+}
+
+/* Function to close a joystick after use */
+void SDL_SYS_JoystickClose(SDL_Joystick *joystick)
+{
+#ifndef NO_LOGICAL_JOYSTICKS
+	register int i;
+	if (SDL_joylist[joystick->index].fname == NULL) {
+		SDL_joylist_head(i, joystick->index);
+		SDL_JoystickClose(SDL_joylist[i].joy);
+	}
+#endif
+
+	if ( joystick->hwdata ) {
+#ifndef NO_LOGICAL_JOYSTICKS
+		if (SDL_joylist[joystick->index].fname != NULL)
+#endif
+		close(joystick->hwdata->fd);
+		if ( joystick->hwdata->hats ) {
+			SDL_free(joystick->hwdata->hats);
+		}
+		if ( joystick->hwdata->balls ) {
+			SDL_free(joystick->hwdata->balls);
+		}
+		SDL_free(joystick->hwdata);
+		joystick->hwdata = NULL;
+	}
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void SDL_SYS_JoystickQuit(void)
+{
+	int i;
+
+	for ( i=0; SDL_joylist[i].fname; ++i ) {
+		SDL_free(SDL_joylist[i].fname);
+		SDL_joylist[i].fname = NULL;
+	}
+}
+
+#endif /* SDL_JOYSTICK_LINUX */

=== added directory '.pc/fix_window_resizing.diff'
=== added directory '.pc/fix_window_resizing.diff/src'
=== added directory '.pc/fix_window_resizing.diff/src/video'
=== added directory '.pc/fix_window_resizing.diff/src/video/x11'
=== added file '.pc/fix_window_resizing.diff/src/video/x11/SDL_x11events.c'
--- .pc/fix_window_resizing.diff/src/video/x11/SDL_x11events.c	1970-01-01 00:00:00 +0000
+++ .pc/fix_window_resizing.diff/src/video/x11/SDL_x11events.c	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1423 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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
+    [e-mail]
+*/
+#include "SDL_config.h"
+
+/* Handle the event stream, converting X11 events into SDL events */
+
+#include <setjmp.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#ifdef __SVR4
+#include <X11/Sunkeysym.h>
+#endif
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "SDL_timer.h"
+#include "SDL_syswm.h"
+#include "../SDL_sysvideo.h"
+#include "../../events/SDL_sysevents.h"
+#include "../../events/SDL_events_c.h"
+#include "SDL_x11video.h"
+#include "SDL_x11dga_c.h"
+#include "SDL_x11modes_c.h"
+#include "SDL_x11image_c.h"
+#include "SDL_x11gamma_c.h"
+#include "SDL_x11wm_c.h"
+#include "SDL_x11mouse_c.h"
+#include "SDL_x11events_c.h"
+
+
+/* Define this if you want to debug X11 events */
+/*#define DEBUG_XEVENTS*/
+
+/* The translation tables from an X11 keysym to a SDL keysym */
+static SDLKey ODD_keymap[256];
+static SDLKey MISC_keymap[256];
+SDLKey X11_TranslateKeycode(Display *display, KeyCode kc);
+
+/*
+ Pending resize target for ConfigureNotify (so outdated events don't
+ cause inappropriate resize events)
+*/
+int X11_PendingConfigureNotifyWidth = -1;
+int X11_PendingConfigureNotifyHeight = -1;
+
+#ifdef X_HAVE_UTF8_STRING
+Uint32 Utf8ToUcs4(const Uint8 *utf8)
+{
+	Uint32 c;
+	int i = 1;
+	int noOctets = 0;
+	int firstOctetMask = 0;
+	unsigned char firstOctet = utf8[0];
+	if (firstOctet < 0x80) {
+		/*
+		  Characters in the range:
+		    00000000 to 01111111 (ASCII Range)
+		  are stored in one octet:
+		    0xxxxxxx (The same as its ASCII representation)
+		  The least 6 significant bits of the first octet is the most 6 significant nonzero bits
+		  of the UCS4 representation.
+		*/
+		noOctets = 1;
+		firstOctetMask = 0x7F;  /* 0(1111111) - The most significant bit is ignored */
+	} else if ((firstOctet & 0xE0) /* get the most 3 significant bits by AND'ing with 11100000 */
+	              == 0xC0 ) {  /* see if those 3 bits are 110. If so, the char is in this range */
+		/*
+		  Characters in the range:
+		    00000000 10000000 to 00000111 11111111
+		  are stored in two octets:
+		    110xxxxx 10xxxxxx
+		  The least 5 significant bits of the first octet is the most 5 significant nonzero bits
+		  of the UCS4 representation.
+		*/
+		noOctets = 2;
+		firstOctetMask = 0x1F;  /* 000(11111) - The most 3 significant bits are ignored */
+	} else if ((firstOctet & 0xF0) /* get the most 4 significant bits by AND'ing with 11110000 */
+	              == 0xE0) {  /* see if those 4 bits are 1110. If so, the char is in this range */
+		/*
+		  Characters in the range:
+		    00001000 00000000 to 11111111 11111111
+		  are stored in three octets:
+		    1110xxxx 10xxxxxx 10xxxxxx
+		  The least 4 significant bits of the first octet is the most 4 significant nonzero bits
+		  of the UCS4 representation.
+		*/
+		noOctets = 3;
+		firstOctetMask = 0x0F; /* 0000(1111) - The most 4 significant bits are ignored */
+	} else if ((firstOctet & 0xF8) /* get the most 5 significant bits by AND'ing with 11111000 */
+	              == 0xF0) {  /* see if those 5 bits are 11110. If so, the char is in this range */
+		/*
+		  Characters in the range:
+		    00000001 00000000 00000000 to 00011111 11111111 11111111
+		  are stored in four octets:
+		    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+		  The least 3 significant bits of the first octet is the most 3 significant nonzero bits
+		  of the UCS4 representation.
+		*/
+		noOctets = 4;
+		firstOctetMask = 0x07; /* 11110(111) - The most 5 significant bits are ignored */
+	} else if ((firstOctet & 0xFC) /* get the most 6 significant bits by AND'ing with 11111100 */
+	              == 0xF8) { /* see if those 6 bits are 111110. If so, the char is in this range */
+		/*
+		  Characters in the range:
+		    00000000 00100000 00000000 00000000 to
+		    00000011 11111111 11111111 11111111
+		  are stored in five octets:
+		    111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+		  The least 2 significant bits of the first octet is the most 2 significant nonzero bits
+		  of the UCS4 representation.
+		*/
+		noOctets = 5;
+		firstOctetMask = 0x03; /* 111110(11) - The most 6 significant bits are ignored */
+	} else if ((firstOctet & 0xFE) /* get the most 7 significant bits by AND'ing with 11111110 */
+	              == 0xFC) { /* see if those 7 bits are 1111110. If so, the char is in this range */
+		/*
+		  Characters in the range:
+		    00000100 00000000 00000000 00000000 to
+		    01111111 11111111 11111111 11111111
+		  are stored in six octets:
+		    1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+		  The least significant bit of the first octet is the most significant nonzero bit
+		  of the UCS4 representation.
+		*/
+		noOctets = 6;
+		firstOctetMask = 0x01; /* 1111110(1) - The most 7 significant bits are ignored */
+	} else
+		return 0;  /* The given chunk is not a valid UTF-8 encoded Unicode character */
+	
+	/*
+	  The least noOctets significant bits of the first octet is the most 2 significant nonzero bits
+	  of the UCS4 representation.
+	  The first 6 bits of the UCS4 representation is the least 8-noOctets-1 significant bits of
+	  firstOctet if the character is not ASCII. If so, it's the least 7 significant bits of firstOctet.
+	  This done by AND'ing firstOctet with its mask to trim the bits used for identifying the
+	  number of continuing octets (if any) and leave only the free bits (the x's)
+	  Sample:
+	  1-octet:    0xxxxxxx  &  01111111 = 0xxxxxxx
+	  2-octets:  110xxxxx  &  00011111 = 000xxxxx
+	*/
+	c = firstOctet & firstOctetMask;
+	
+	/* Now, start filling c.ucs4 with the bits from the continuing octets from utf8. */
+	for (i = 1; i < noOctets; i++) {
+		/* A valid continuing octet is of the form 10xxxxxx */
+		if ((utf8[i] & 0xC0) /* get the most 2 significant bits by AND'ing with 11000000 */
+		    != 0x80) /* see if those 2 bits are 10. If not, the is a malformed sequence. */
+			/*The given chunk is a partial sequence at the end of a string that could
+			   begin a valid character */
+			return 0;
+		
+		/* Make room for the next 6-bits */
+		c <<= 6;
+		
+		/*
+		  Take only the least 6 significance bits of the current octet (utf8[i]) and fill the created room
+		  of c.ucs4 with them.
+		  This done by AND'ing utf8[i] with 00111111 and the OR'ing the result with c.ucs4.
+		*/
+		c |= utf8[i] & 0x3F;
+	}
+	return c;
+}
+
+/* Given a UTF-8 encoded string pointed to by utf8 of length length in
+   bytes, returns the corresponding UTF-16 encoded string in the
+   buffer pointed to by utf16.  The maximum number of UTF-16 encoding
+   units (i.e., Unit16s) allowed in the buffer is specified in
+   utf16_max_length.  The return value is the number of UTF-16
+   encoding units placed in the output buffer pointed to by utf16.
+
+   In case of an error, -1 is returned, leaving some unusable partial
+   results in the output buffer.
+
+   The caller must estimate the size of utf16 buffer by itself before
+   calling this function.  Insufficient output buffer is considered as
+   an error, and once an error occured, this function doesn't give any
+   clue how large the result will be.
+
+   The error cases include following:
+
+   - Invalid byte sequences were in the input UTF-8 bytes.  The caller
+     has no way to know what point in the input buffer was the
+     errornous byte.
+
+   - The input contained a character (a valid UTF-8 byte sequence)
+     whose scalar value exceeded the range that UTF-16 can represent
+     (i.e., characters whose Unicode scalar value above 0x110000).
+
+   - The output buffer has no enough space to hold entire utf16 data.
+
+   Please note:
+
+   - '\0'-termination is not assumed both on the input UTF-8 string
+     and on the output UTF-16 string; any legal zero byte in the input
+     UTF-8 string will be converted to a 16-bit zero in output.  As a
+     side effect, the last UTF-16 encoding unit stored in the output
+     buffer will have a non-zero value if the input UTF-8 was not
+     '\0'-terminated.
+
+   - UTF-8 aliases are *not* considered as an error.  They are
+     converted to UTF-16.  For example, 0xC0 0xA0, 0xE0 0x80 0xA0, 
+     and 0xF0 0x80 0x80 0xA0 are all mapped to a single UTF-16
+     encoding unit 0x0020.
+
+   - Three byte UTF-8 sequences whose value corresponds to a surrogate
+     code or other reserved scalar value are not considered as an
+     error either.  They may cause an invalid UTF-16 data (e.g., those
+     containing unpaired surrogates).
+
+*/
+
+static int Utf8ToUtf16(const Uint8 *utf8, const int utf8_length, Uint16 *utf16, const int utf16_max_length) {
+
+    /* p moves over the output buffer.  max_ptr points to the next to the last slot of the buffer.  */
+    Uint16 *p = utf16;
+    Uint16 const *const max_ptr = utf16 + utf16_max_length;
+
+    /* end_of_input points to the last byte of input as opposed to the next to the last byte.  */
+    Uint8 const *const end_of_input = utf8 + utf8_length - 1;
+
+    while (utf8 <= end_of_input) {
+	Uint8 const c = *utf8;
+	if (p >= max_ptr) {
+	    /* No more output space.  */
+	    return -1;
+	}
+	if (c < 0x80) {
+	    /* One byte ASCII.  */
+	    *p++ = c;
+	    utf8 += 1;
+	} else if (c < 0xC0) {
+	    /* Follower byte without preceeding leader bytes.  */
+	    return -1;
+	} else if (c < 0xE0) {
+	    /* Two byte sequence.  We need one follower byte.  */
+	    if (end_of_input - utf8 < 1 || (((utf8[1] ^ 0x80)) & 0xC0)) {
+		return -1;
+	    }
+	    *p++ = (Uint16)(0xCF80 + (c << 6) + utf8[1]);
+	    utf8 += 2;
+	} else if (c < 0xF0) {
+	    /* Three byte sequence.  We need two follower byte.  */
+	    if (end_of_input - utf8 < 2 || (((utf8[1] ^ 0x80) | (utf8[2] ^ 0x80)) & 0xC0)) {
+		return -1;
+	    }
+	    *p++ = (Uint16)(0xDF80 + (c << 12) + (utf8[1] << 6) + utf8[2]);
+	    utf8 += 3;
+	} else if (c < 0xF8) {
+	    int plane;
+	    /* Four byte sequence.  We need three follower bytes.  */
+	    if (end_of_input - utf8 < 3 || (((utf8[1] ^ 0x80) | (utf8[2] ^0x80) | (utf8[3] ^ 0x80)) & 0xC0)) {
+		return -1;
+	    }
+	    plane = (-0xC8 + (c << 2) + (utf8[1] >> 4));
+	    if (plane == 0) {
+		/* This four byte sequence is an alias that
+                   corresponds to a Unicode scalar value in BMP.
+		   It fits in an UTF-16 encoding unit.  */
+		*p++ = (Uint16)(0xDF80 + (utf8[1] << 12) + (utf8[2] << 6) + utf8[3]);
+	    } else if (plane <= 16) {
+		/* This is a legal four byte sequence that corresponds to a surrogate pair.  */
+		if (p + 1 >= max_ptr) {
+		    /* No enough space on the output buffer for the pair.  */
+		    return -1;
+		}
+		*p++ = (Uint16)(0xE5B8 + (c << 8) + (utf8[1] << 2) + (utf8[2] >> 4));
+		*p++ = (Uint16)(0xDB80 + ((utf8[2] & 0x0F) << 6) + utf8[3]);
+	    } else {
+		/* This four byte sequence is out of UTF-16 code space.  */
+		return -1;
+	    }
+	    utf8 += 4;
+	} else {
+	    /* Longer sequence or unused byte.  */
+	    return -1;
+	}
+    }
+    return p - utf16;
+}
+
+#endif
+
+/* Check to see if this is a repeated key.
+   (idea shamelessly lifted from GII -- thanks guys! :)
+ */
+static int X11_KeyRepeat(Display *display, XEvent *event)
+{
+	XEvent peekevent;
+	int repeated;
+
+	repeated = 0;
+	if ( XPending(display) ) {
+		XPeekEvent(display, &peekevent);
+		if ( (peekevent.type == KeyPress) &&
+		     (peekevent.xkey.keycode == event->xkey.keycode) &&
+		     ((peekevent.xkey.time-event->xkey.time) < 2) ) {
+			repeated = 1;
+			XNextEvent(display, &peekevent);
+		}
+	}
+	return(repeated);
+}
+
+/* Note:  The X server buffers and accumulates mouse motion events, so
+   the motion event generated by the warp may not appear exactly as we
+   expect it to.  We work around this (and improve performance) by only
+   warping the pointer when it reaches the edge, and then wait for it.
+*/
+#define MOUSE_FUDGE_FACTOR	8
+
+static __inline__ int X11_WarpedMotion(_THIS, XEvent *xevent)
+{
+	int w, h, i;
+	int deltax, deltay;
+	int posted;
+
+	w = SDL_VideoSurface->w;
+	h = SDL_VideoSurface->h;
+	deltax = xevent->xmotion.x - mouse_last.x;
+	deltay = xevent->xmotion.y - mouse_last.y;
+#ifdef DEBUG_MOTION
+  printf("Warped mouse motion: %d,%d\n", deltax, deltay);
+#endif
+	mouse_last.x = xevent->xmotion.x;
+	mouse_last.y = xevent->xmotion.y;
+	posted = SDL_PrivateMouseMotion(0, 1, deltax, deltay);
+
+	if ( (xevent->xmotion.x < MOUSE_FUDGE_FACTOR) ||
+	     (xevent->xmotion.x > (w-MOUSE_FUDGE_FACTOR)) ||
+	     (xevent->xmotion.y < MOUSE_FUDGE_FACTOR) ||
+	     (xevent->xmotion.y > (h-MOUSE_FUDGE_FACTOR)) ) {
+		/* Get the events that have accumulated */
+		while ( XCheckTypedEvent(SDL_Display, MotionNotify, xevent) ) {
+			deltax = xevent->xmotion.x - mouse_last.x;
+			deltay = xevent->xmotion.y - mouse_last.y;
+#ifdef DEBUG_MOTION
+  printf("Extra mouse motion: %d,%d\n", deltax, deltay);
+#endif
+			mouse_last.x = xevent->xmotion.x;
+			mouse_last.y = xevent->xmotion.y;
+			posted += SDL_PrivateMouseMotion(0, 1, deltax, deltay);
+		}
+		mouse_last.x = w/2;
+		mouse_last.y = h/2;
+		XWarpPointer(SDL_Display, None, SDL_Window, 0, 0, 0, 0,
+					mouse_last.x, mouse_last.y);
+		for ( i=0; i<10; ++i ) {
+        		XMaskEvent(SDL_Display, PointerMotionMask, xevent);
+			if ( (xevent->xmotion.x >
+			          (mouse_last.x-MOUSE_FUDGE_FACTOR)) &&
+			     (xevent->xmotion.x <
+			          (mouse_last.x+MOUSE_FUDGE_FACTOR)) &&
+			     (xevent->xmotion.y >
+			          (mouse_last.y-MOUSE_FUDGE_FACTOR)) &&
+			     (xevent->xmotion.y <
+			          (mouse_last.y+MOUSE_FUDGE_FACTOR)) ) {
+				break;
+			}
+#ifdef DEBUG_XEVENTS
+  printf("Lost mouse motion: %d,%d\n", xevent->xmotion.x, xevent->xmotion.y);
+#endif
+		}
+#ifdef DEBUG_XEVENTS
+		if ( i == 10 ) {
+			printf("Warning: didn't detect mouse warp motion\n");
+		}
+#endif
+	}
+	return(posted);
+}
+
+static int X11_DispatchEvent(_THIS)
+{
+	int posted;
+	XEvent xevent;
+
+	SDL_memset(&xevent, '\0', sizeof (XEvent));  /* valgrind fix. --ryan. */
+	XNextEvent(SDL_Display, &xevent);
+
+	/* Discard KeyRelease and KeyPress events generated by auto-repeat.
+	   We need to do it before passing event to XFilterEvent.  Otherwise,
+	   KeyRelease aware IMs are confused...  */
+	if ( xevent.type == KeyRelease
+	     && X11_KeyRepeat(SDL_Display, &xevent) ) {
+		return 0;
+	}
+
+#ifdef X_HAVE_UTF8_STRING
+	/* If we are translating with IM, we need to pass all events
+	   to XFilterEvent, and discard those filtered events immediately.  */
+	if ( SDL_TranslateUNICODE
+	     && SDL_IM != NULL
+	     && XFilterEvent(&xevent, None) ) {
+		return 0;
+	}
+#endif
+
+	posted = 0;
+	switch (xevent.type) {
+
+	    /* Gaining mouse coverage? */
+	    case EnterNotify: {
+#ifdef DEBUG_XEVENTS
+printf("EnterNotify! (%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y);
+if ( xevent.xcrossing.mode == NotifyGrab )
+printf("Mode: NotifyGrab\n");
+if ( xevent.xcrossing.mode == NotifyUngrab )
+printf("Mode: NotifyUngrab\n");
+#endif
+		if ( this->input_grab == SDL_GRAB_OFF ) {
+			posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
+		}
+		posted = SDL_PrivateMouseMotion(0, 0,
+				xevent.xcrossing.x,
+				xevent.xcrossing.y);
+	    }
+	    break;
+
+	    /* Losing mouse coverage? */
+	    case LeaveNotify: {
+#ifdef DEBUG_XEVENTS
+printf("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y);
+if ( xevent.xcrossing.mode == NotifyGrab )
+printf("Mode: NotifyGrab\n");
+if ( xevent.xcrossing.mode == NotifyUngrab )
+printf("Mode: NotifyUngrab\n");
+#endif
+		if ( (xevent.xcrossing.mode != NotifyGrab) &&
+		     (xevent.xcrossing.mode != NotifyUngrab) &&
+		     (xevent.xcrossing.detail != NotifyInferior) ) {
+               		if ( this->input_grab == SDL_GRAB_OFF ) {
+				posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
+			} else {
+				posted = SDL_PrivateMouseMotion(0, 0,
+						xevent.xcrossing.x,
+						xevent.xcrossing.y);
+			}
+		}
+	    }
+	    break;
+
+	    /* Gaining input focus? */
+	    case FocusIn: {
+#ifdef DEBUG_XEVENTS
+printf("FocusIn!\n");
+#endif
+		posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
+
+#ifdef X_HAVE_UTF8_STRING
+		if ( SDL_IC != NULL ) {
+			XSetICFocus(SDL_IC);
+		}
+#endif
+		/* Queue entry into fullscreen mode */
+		switch_waiting = 0x01 | SDL_FULLSCREEN;
+		switch_time = SDL_GetTicks() + 1500;
+	    }
+	    break;
+
+	    /* Losing input focus? */
+	    case FocusOut: {
+#ifdef DEBUG_XEVENTS
+printf("FocusOut!\n");
+#endif
+		posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
+
+#ifdef X_HAVE_UTF8_STRING
+		if ( SDL_IC != NULL ) {
+			XUnsetICFocus(SDL_IC);
+		}
+#endif
+		/* Queue leaving fullscreen mode */
+		switch_waiting = 0x01;
+		switch_time = SDL_GetTicks() + 200;
+	    }
+	    break;
+
+#ifdef X_HAVE_UTF8_STRING
+	    /* Some IM requires MappingNotify to be passed to
+	       XRefreshKeyboardMapping by the app.  */
+	    case MappingNotify: {
+		XRefreshKeyboardMapping(&xevent.xmapping);
+	    }
+	    break;
+#endif /* X_HAVE_UTF8_STRING */
+
+	    /* Generated upon EnterWindow and FocusIn */
+	    case KeymapNotify: {
+#ifdef DEBUG_XEVENTS
+printf("KeymapNotify!\n");
+#endif
+		X11_SetKeyboardState(SDL_Display,  xevent.xkeymap.key_vector);
+	    }
+	    break;
+
+	    /* Mouse motion? */
+	    case MotionNotify: {
+		if ( SDL_VideoSurface ) {
+			if ( mouse_relative ) {
+				if ( using_dga & DGA_MOUSE ) {
+#ifdef DEBUG_MOTION
+  printf("DGA motion: %d,%d\n", xevent.xmotion.x_root, xevent.xmotion.y_root);
+#endif
+					posted = SDL_PrivateMouseMotion(0, 1,
+							xevent.xmotion.x_root,
+							xevent.xmotion.y_root);
+				} else {
+					posted = X11_WarpedMotion(this,&xevent);
+				}
+			} else {
+#ifdef DEBUG_MOTION
+  printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y);
+#endif
+				posted = SDL_PrivateMouseMotion(0, 0,
+						xevent.xmotion.x,
+						xevent.xmotion.y);
+			}
+		}
+	    }
+	    break;
+
+	    /* Mouse button press? */
+	    case ButtonPress: {
+		posted = SDL_PrivateMouseButton(SDL_PRESSED, 
+					xevent.xbutton.button, 0, 0);
+	    }
+	    break;
+
+	    /* Mouse button release? */
+	    case ButtonRelease: {
+		posted = SDL_PrivateMouseButton(SDL_RELEASED, 
+					xevent.xbutton.button, 0, 0);
+	    }
+	    break;
+
+	    /* Key press? */
+	    case KeyPress: {
+		SDL_keysym keysym;
+		KeyCode keycode = xevent.xkey.keycode;
+
+#ifdef DEBUG_XEVENTS
+printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
+#endif
+		/* If we're not doing translation, we're done! */
+		if ( !SDL_TranslateUNICODE ) {
+			/* Get the translated SDL virtual keysym and put it on the queue.*/
+			keysym.scancode = keycode;
+			keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
+			keysym.mod = KMOD_NONE;
+			keysym.unicode = 0;
+			posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+			break;
+		}
+
+		/* Look up the translated value for the key event */
+#ifdef X_HAVE_UTF8_STRING
+		if ( SDL_IC != NULL ) {
+			Status status;
+			KeySym xkeysym;
+			int i;
+			/* A UTF-8 character can be at most 6 bytes */
+			/* ... It's true, but Xutf8LookupString can
+			   return more than one characters.  Moreover,
+			   the spec. put no upper bound, so we should
+			   be ready for longer strings.  */
+			char keybuf[32];
+			char *keydata = keybuf;
+			int count;
+			Uint16 utf16buf[32];
+			Uint16 *utf16data = utf16buf;
+			int utf16size;
+			int utf16length;
+
+			count = Xutf8LookupString(SDL_IC, &xevent.xkey, keydata, sizeof(keybuf), &xkeysym, &status);
+			if (XBufferOverflow == status) {
+			  /* The IM has just generated somewhat long
+			     string.  We need a longer buffer in this
+			     case.  */
+			  keydata = SDL_malloc(count);
+			  if ( keydata == NULL ) {
+			    SDL_OutOfMemory();
+			    break;
+			  }
+			  count = Xutf8LookupString(SDL_IC, &xevent.xkey, keydata, count, &xkeysym, &status);
+			}
+
+			switch (status) {
+
+			case XBufferOverflow: {
+			  /* Oops!  We have allocated the bytes as
+			     requested by Xutf8LookupString, so the
+			     length of the buffer must be
+			     sufficient.  This case should never
+			     happen! */
+			  SDL_SetError("Xutf8LookupString indicated a double buffer overflow!");
+			  break;
+			}
+
+			case XLookupChars:
+			case XLookupBoth: {
+			  if (0 == count) {
+			    break;
+			  }
+
+			  /* We got a converted string from IM.  Make
+			     sure to deliver all characters to the
+			     application as SDL events.  Note that
+			     an SDL event can only carry one UTF-16
+			     encoding unit, and a surrogate pair is
+			     delivered as two SDL events.  I guess
+			     this behaviour is probably _imported_
+			     from Windows or MacOS.  To do so, we need
+			     to convert the UTF-8 data into UTF-16
+			     data (not UCS4/UTF-32!).  We need an
+			     estimate of the number of UTF-16 encoding
+			     units here.  The worst case is pure ASCII
+			     string.  Assume so. */
+			  /* In 1.3 SDL may have a text event instead, that
+			     carries the whole UTF-8 string with it. */
+			  utf16size = count * sizeof(Uint16);
+			  if (utf16size > sizeof(utf16buf)) {
+			    utf16data = (Uint16 *) SDL_malloc(utf16size);
+			    if (utf16data == NULL) {
+			      SDL_OutOfMemory();
+			      break;
+			    }
+			  }
+			  utf16length = Utf8ToUtf16((Uint8 *)keydata, count, utf16data, utf16size);
+			  if (utf16length < 0) {
+			    /* The keydata contained an invalid byte
+			       sequence.  It should be a bug of the IM
+			       or Xlib... */
+			    SDL_SetError("Oops! Xutf8LookupString returned an invalid UTF-8 sequence!");
+			    break;
+			  }
+
+			  /* Deliver all UTF-16 encoding units.  At
+			     this moment, SDL event queue has a
+			     fixed size (128 events), and an SDL
+			     event can hold just one UTF-16 encoding
+			     unit.  So, if we receive more than 128
+			     UTF-16 encoding units from a commit,
+			     exceeded characters will be lost.  */
+			  for (i = 0; i < utf16length - 1; i++) {
+			    keysym.scancode = 0;
+			    keysym.sym = SDLK_UNKNOWN;
+			    keysym.mod = KMOD_NONE;
+			    keysym.unicode = utf16data[i];
+			    posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+			  }
+			  /* The keysym for the last character carries the
+			     scancode and symbol that corresponds to the X11
+			     keycode.  */
+			  if (utf16length > 0) {			       
+			    keysym.scancode = keycode;
+			    keysym.sym = (keycode ? X11_TranslateKeycode(SDL_Display, keycode) : 0);
+			    keysym.mod = KMOD_NONE;
+			    keysym.unicode = utf16data[utf16length - 1];
+			    posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+			  }
+			  break;
+			}
+
+			case XLookupKeySym: {
+			  /* I'm not sure whether it is possible that
+			     a zero keycode makes XLookupKeySym
+			     status.  What I'm sure is that a
+			     combination of a zero scan code and a non
+			     zero sym makes SDL_PrivateKeyboard
+			     strange state...  So, just discard it.
+			     If this doesn't work, I'm receiving bug
+			     reports, and I can know under what
+			     condition this case happens.  */
+			  if (keycode) {
+			    keysym.scancode = keycode;
+			    keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
+			    keysym.mod = KMOD_NONE;
+			    keysym.unicode = 0;
+			    posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+			  }
+			  break;
+			}
+
+			case XLookupNone: {
+			  /* IM has eaten the event.  */
+			  break;
+			}
+
+			default:
+			  /* An unknown status from Xutf8LookupString.  */
+			  SDL_SetError("Oops! Xutf8LookupStringreturned an unknown status");
+			}
+
+			/* Release dynamic buffers if allocated.  */
+			if (keydata != NULL && keybuf != keydata) {
+			  SDL_free(keydata);
+			}
+			if (utf16data != NULL && utf16buf != utf16data) {
+			  SDL_free(utf16data);
+			}
+		}
+		else
+#endif
+		{
+			static XComposeStatus state;
+			char keybuf[32];
+
+			keysym.scancode = keycode;
+			keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
+			keysym.mod = KMOD_NONE;
+			keysym.unicode = 0;
+			if ( XLookupString(&xevent.xkey,
+			                    keybuf, sizeof(keybuf),
+			                    NULL, &state) ) {
+				/*
+				* FIXME: XLookupString() may yield more than one
+				* character, so we need a mechanism to allow for
+				* this (perhaps null keypress events with a
+				* unicode value)
+				*/
+				keysym.unicode = (Uint8)keybuf[0];
+			}
+
+			posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+		}
+	    }
+	    break;
+
+	    /* Key release? */
+	    case KeyRelease: {
+		SDL_keysym keysym;
+		KeyCode keycode = xevent.xkey.keycode;
+
+		if (keycode == 0) {
+		  /* There should be no KeyRelease for keycode == 0,
+		     since it is a notification from IM but a real
+		     keystroke.  */
+		  /* We need to emit some diagnostic message here.  */
+		  break;
+		}
+
+#ifdef DEBUG_XEVENTS
+printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
+#endif
+
+		/* Get the translated SDL virtual keysym */
+		keysym.scancode = keycode;
+		keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
+		keysym.mod = KMOD_NONE;
+		keysym.unicode = 0;
+
+		posted = SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
+	    }
+	    break;
+
+	    /* Have we been iconified? */
+	    case UnmapNotify: {
+#ifdef DEBUG_XEVENTS
+printf("UnmapNotify!\n");
+#endif
+		/* If we're active, make ourselves inactive */
+		if ( SDL_GetAppState() & SDL_APPACTIVE ) {
+			/* Swap out the gamma before we go inactive */
+			X11_SwapVidModeGamma(this);
+
+			/* Send an internal deactivate event */
+			posted = SDL_PrivateAppActive(0,
+					SDL_APPACTIVE|SDL_APPINPUTFOCUS);
+		}
+	    }
+	    break;
+
+	    /* Have we been restored? */
+	    case MapNotify: {
+#ifdef DEBUG_XEVENTS
+printf("MapNotify!\n");
+#endif
+		/* If we're not active, make ourselves active */
+		if ( !(SDL_GetAppState() & SDL_APPACTIVE) ) {
+			/* Send an internal activate event */
+			posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
+
+			/* Now that we're active, swap the gamma back */
+			X11_SwapVidModeGamma(this);
+		}
+
+		if ( SDL_VideoSurface &&
+		     (SDL_VideoSurface->flags & SDL_FULLSCREEN) ) {
+			X11_EnterFullScreen(this);
+		} else {
+			X11_GrabInputNoLock(this, this->input_grab);
+		}
+		X11_CheckMouseModeNoLock(this);
+
+		if ( SDL_VideoSurface ) {
+			X11_RefreshDisplay(this);
+		}
+	    }
+	    break;
+
+	    /* Have we been resized or moved? */
+	    case ConfigureNotify: {
+#ifdef DEBUG_XEVENTS
+printf("ConfigureNotify! (resize: %dx%d)\n", xevent.xconfigure.width, xevent.xconfigure.height);
+#endif
+		if ((X11_PendingConfigureNotifyWidth != -1) &&
+		    (X11_PendingConfigureNotifyHeight != -1)) {
+		    if ((xevent.xconfigure.width != X11_PendingConfigureNotifyWidth) &&
+			(xevent.xconfigure.height != X11_PendingConfigureNotifyHeight)) {
+			    /* Event is from before the resize, so ignore. */
+			    break;
+		    }
+		    X11_PendingConfigureNotifyWidth = -1;
+		    X11_PendingConfigureNotifyHeight = -1;
+		}
+		if ( SDL_VideoSurface ) {
+		    if ((xevent.xconfigure.width != SDL_VideoSurface->w) ||
+		        (xevent.xconfigure.height != SDL_VideoSurface->h)) {
+			/* FIXME: Find a better fix for the bug with KDE 1.2 */
+			if ( ! ((xevent.xconfigure.width == 32) &&
+			        (xevent.xconfigure.height == 32)) ) {
+				SDL_PrivateResize(xevent.xconfigure.width,
+				                  xevent.xconfigure.height);
+			}
+		    } else {
+			/* OpenGL windows need to know about the change */
+			if ( SDL_VideoSurface->flags & SDL_OPENGL ) {
+				SDL_PrivateExpose();
+			}
+		    }
+		}
+	    }
+	    break;
+
+	    /* Have we been requested to quit (or another client message?) */
+	    case ClientMessage: {
+		if ( (xevent.xclient.format == 32) &&
+		     (xevent.xclient.data.l[0] == WM_DELETE_WINDOW) )
+		{
+			posted = SDL_PrivateQuit();
+		} else
+		if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
+			SDL_SysWMmsg wmmsg;
+
+			SDL_VERSION(&wmmsg.version);
+			wmmsg.subsystem = SDL_SYSWM_X11;
+			wmmsg.event.xevent = xevent;
+			posted = SDL_PrivateSysWMEvent(&wmmsg);
+		}
+	    }
+	    break;
+
+	    /* Do we need to refresh ourselves? */
+	    case Expose: {
+#ifdef DEBUG_XEVENTS
+printf("Expose (count = %d)\n", xevent.xexpose.count);
+#endif
+		if ( SDL_VideoSurface && (xevent.xexpose.count == 0) ) {
+			X11_RefreshDisplay(this);
+		}
+	    }
+	    break;
+
+	    default: {
+#ifdef DEBUG_XEVENTS
+printf("Unhandled event %d\n", xevent.type);
+#endif
+		/* Only post the event if we're watching for it */
+		if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
+			SDL_SysWMmsg wmmsg;
+
+			SDL_VERSION(&wmmsg.version);
+			wmmsg.subsystem = SDL_SYSWM_X11;
+			wmmsg.event.xevent = xevent;
+			posted = SDL_PrivateSysWMEvent(&wmmsg);
+		}
+	    }
+	    break;
+	}
+	return(posted);
+}
+
+/* Ack!  XPending() actually performs a blocking read if no events available */
+int X11_Pending(Display *display)
+{
+	/* Flush the display connection and look to see if events are queued */
+	XFlush(display);
+	if ( XEventsQueued(display, QueuedAlready) ) {
+		return(1);
+	}
+
+	/* More drastic measures are required -- see if X is ready to talk */
+	{
+		static struct timeval zero_time;	/* static == 0 */
+		int x11_fd;
+		fd_set fdset;
+
+		x11_fd = ConnectionNumber(display);
+		FD_ZERO(&fdset);
+		FD_SET(x11_fd, &fdset);
+		if ( select(x11_fd+1, &fdset, NULL, NULL, &zero_time) == 1 ) {
+			return(XPending(display));
+		}
+	}
+
+	/* Oh well, nothing is ready .. */
+	return(0);
+}
+
+void X11_PumpEvents(_THIS)
+{
+	int pending;
+
+	/* Update activity every five seconds to prevent screensaver. --ryan. */
+	if (!allow_screensaver) {
+		static Uint32 screensaverTicks;
+		Uint32 nowTicks = SDL_GetTicks();
+		if ((nowTicks - screensaverTicks) > 5000) {
+			XResetScreenSaver(SDL_Display);
+			screensaverTicks = nowTicks;
+		}
+	}
+
+	/* Keep processing pending events */
+	pending = 0;
+	while ( X11_Pending(SDL_Display) ) {
+		X11_DispatchEvent(this);
+		++pending;
+	}
+	if ( switch_waiting ) {
+		Uint32 now;
+
+		now  = SDL_GetTicks();
+		if ( pending || !SDL_VideoSurface ) {
+			/* Try again later... */
+			if ( switch_waiting & SDL_FULLSCREEN ) {
+				switch_time = now + 1500;
+			} else {
+				switch_time = now + 200;
+			}
+		} else if ( (int)(switch_time-now) <= 0 ) {
+			Uint32 go_fullscreen;
+
+			go_fullscreen = switch_waiting & SDL_FULLSCREEN;
+			switch_waiting = 0;
+			if ( SDL_VideoSurface->flags & SDL_FULLSCREEN ) {
+				if ( go_fullscreen ) {
+					X11_EnterFullScreen(this);
+				} else {
+					X11_LeaveFullScreen(this);
+				}
+			}
+			/* Handle focus in/out when grabbed */
+			if ( go_fullscreen ) {
+				X11_GrabInputNoLock(this, this->input_grab);
+			} else {
+				X11_GrabInputNoLock(this, SDL_GRAB_OFF);
+			}
+			X11_CheckMouseModeNoLock(this);
+		}
+	}
+}
+
+void X11_InitKeymap(void)
+{
+	int i;
+
+	/* Odd keys used in international keyboards */
+	for ( i=0; i<SDL_arraysize(ODD_keymap); ++i )
+		ODD_keymap[i] = SDLK_UNKNOWN;
+
+ 	/* Some of these might be mappable to an existing SDLK_ code */
+ 	ODD_keymap[XK_dead_grave&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_acute&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_tilde&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_macron&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_breve&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_abovedot&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_diaeresis&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_abovering&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_doubleacute&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_caron&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_cedilla&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_ogonek&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_iota&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_voiced_sound&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_semivoiced_sound&0xFF] = SDLK_COMPOSE;
+ 	ODD_keymap[XK_dead_belowdot&0xFF] = SDLK_COMPOSE;
+#ifdef XK_dead_hook
+ 	ODD_keymap[XK_dead_hook&0xFF] = SDLK_COMPOSE;
+#endif
+#ifdef XK_dead_horn
+ 	ODD_keymap[XK_dead_horn&0xFF] = SDLK_COMPOSE;
+#endif
+
+#ifdef XK_dead_circumflex
+	/* These X keysyms have 0xFE as the high byte */
+	ODD_keymap[XK_dead_circumflex&0xFF] = SDLK_CARET;
+#endif
+#ifdef XK_ISO_Level3_Shift
+	ODD_keymap[XK_ISO_Level3_Shift&0xFF] = SDLK_MODE; /* "Alt Gr" key */
+#endif
+
+	/* Map the miscellaneous keys */
+	for ( i=0; i<SDL_arraysize(MISC_keymap); ++i )
+		MISC_keymap[i] = SDLK_UNKNOWN;
+
+	/* These X keysyms have 0xFF as the high byte */
+	MISC_keymap[XK_BackSpace&0xFF] = SDLK_BACKSPACE;
+	MISC_keymap[XK_Tab&0xFF] = SDLK_TAB;
+	MISC_keymap[XK_Clear&0xFF] = SDLK_CLEAR;
+	MISC_keymap[XK_Return&0xFF] = SDLK_RETURN;
+	MISC_keymap[XK_Pause&0xFF] = SDLK_PAUSE;
+	MISC_keymap[XK_Escape&0xFF] = SDLK_ESCAPE;
+	MISC_keymap[XK_Delete&0xFF] = SDLK_DELETE;
+
+	MISC_keymap[XK_KP_0&0xFF] = SDLK_KP0;		/* Keypad 0-9 */
+	MISC_keymap[XK_KP_1&0xFF] = SDLK_KP1;
+	MISC_keymap[XK_KP_2&0xFF] = SDLK_KP2;
+	MISC_keymap[XK_KP_3&0xFF] = SDLK_KP3;
+	MISC_keymap[XK_KP_4&0xFF] = SDLK_KP4;
+	MISC_keymap[XK_KP_5&0xFF] = SDLK_KP5;
+	MISC_keymap[XK_KP_6&0xFF] = SDLK_KP6;
+	MISC_keymap[XK_KP_7&0xFF] = SDLK_KP7;
+	MISC_keymap[XK_KP_8&0xFF] = SDLK_KP8;
+	MISC_keymap[XK_KP_9&0xFF] = SDLK_KP9;
+	MISC_keymap[XK_KP_Insert&0xFF] = SDLK_KP0;
+	MISC_keymap[XK_KP_End&0xFF] = SDLK_KP1;	
+	MISC_keymap[XK_KP_Down&0xFF] = SDLK_KP2;
+	MISC_keymap[XK_KP_Page_Down&0xFF] = SDLK_KP3;
+	MISC_keymap[XK_KP_Left&0xFF] = SDLK_KP4;
+	MISC_keymap[XK_KP_Begin&0xFF] = SDLK_KP5;
+	MISC_keymap[XK_KP_Right&0xFF] = SDLK_KP6;
+	MISC_keymap[XK_KP_Home&0xFF] = SDLK_KP7;
+	MISC_keymap[XK_KP_Up&0xFF] = SDLK_KP8;
+	MISC_keymap[XK_KP_Page_Up&0xFF] = SDLK_KP9;
+	MISC_keymap[XK_KP_Delete&0xFF] = SDLK_KP_PERIOD;
+	MISC_keymap[XK_KP_Decimal&0xFF] = SDLK_KP_PERIOD;
+	MISC_keymap[XK_KP_Divide&0xFF] = SDLK_KP_DIVIDE;
+	MISC_keymap[XK_KP_Multiply&0xFF] = SDLK_KP_MULTIPLY;
+	MISC_keymap[XK_KP_Subtract&0xFF] = SDLK_KP_MINUS;
+	MISC_keymap[XK_KP_Add&0xFF] = SDLK_KP_PLUS;
+	MISC_keymap[XK_KP_Enter&0xFF] = SDLK_KP_ENTER;
+	MISC_keymap[XK_KP_Equal&0xFF] = SDLK_KP_EQUALS;
+
+	MISC_keymap[XK_Up&0xFF] = SDLK_UP;
+	MISC_keymap[XK_Down&0xFF] = SDLK_DOWN;
+	MISC_keymap[XK_Right&0xFF] = SDLK_RIGHT;
+	MISC_keymap[XK_Left&0xFF] = SDLK_LEFT;
+	MISC_keymap[XK_Insert&0xFF] = SDLK_INSERT;
+	MISC_keymap[XK_Home&0xFF] = SDLK_HOME;
+	MISC_keymap[XK_End&0xFF] = SDLK_END;
+	MISC_keymap[XK_Page_Up&0xFF] = SDLK_PAGEUP;
+	MISC_keymap[XK_Page_Down&0xFF] = SDLK_PAGEDOWN;
+
+	MISC_keymap[XK_F1&0xFF] = SDLK_F1;
+	MISC_keymap[XK_F2&0xFF] = SDLK_F2;
+	MISC_keymap[XK_F3&0xFF] = SDLK_F3;
+	MISC_keymap[XK_F4&0xFF] = SDLK_F4;
+	MISC_keymap[XK_F5&0xFF] = SDLK_F5;
+	MISC_keymap[XK_F6&0xFF] = SDLK_F6;
+	MISC_keymap[XK_F7&0xFF] = SDLK_F7;
+	MISC_keymap[XK_F8&0xFF] = SDLK_F8;
+	MISC_keymap[XK_F9&0xFF] = SDLK_F9;
+	MISC_keymap[XK_F10&0xFF] = SDLK_F10;
+	MISC_keymap[XK_F11&0xFF] = SDLK_F11;
+	MISC_keymap[XK_F12&0xFF] = SDLK_F12;
+	MISC_keymap[XK_F13&0xFF] = SDLK_F13;
+	MISC_keymap[XK_F14&0xFF] = SDLK_F14;
+	MISC_keymap[XK_F15&0xFF] = SDLK_F15;
+
+	MISC_keymap[XK_Num_Lock&0xFF] = SDLK_NUMLOCK;
+	MISC_keymap[XK_Caps_Lock&0xFF] = SDLK_CAPSLOCK;
+	MISC_keymap[XK_Scroll_Lock&0xFF] = SDLK_SCROLLOCK;
+	MISC_keymap[XK_Shift_R&0xFF] = SDLK_RSHIFT;
+	MISC_keymap[XK_Shift_L&0xFF] = SDLK_LSHIFT;
+	MISC_keymap[XK_Control_R&0xFF] = SDLK_RCTRL;
+	MISC_keymap[XK_Control_L&0xFF] = SDLK_LCTRL;
+	MISC_keymap[XK_Alt_R&0xFF] = SDLK_RALT;
+	MISC_keymap[XK_Alt_L&0xFF] = SDLK_LALT;
+	MISC_keymap[XK_Meta_R&0xFF] = SDLK_RMETA;
+	MISC_keymap[XK_Meta_L&0xFF] = SDLK_LMETA;
+	MISC_keymap[XK_Super_L&0xFF] = SDLK_LSUPER; /* Left "Windows" */
+	MISC_keymap[XK_Super_R&0xFF] = SDLK_RSUPER; /* Right "Windows */
+	MISC_keymap[XK_Mode_switch&0xFF] = SDLK_MODE; /* "Alt Gr" key */
+	MISC_keymap[XK_Multi_key&0xFF] = SDLK_COMPOSE; /* Multi-key compose */
+
+	MISC_keymap[XK_Help&0xFF] = SDLK_HELP;
+	MISC_keymap[XK_Print&0xFF] = SDLK_PRINT;
+	MISC_keymap[XK_Sys_Req&0xFF] = SDLK_SYSREQ;
+	MISC_keymap[XK_Break&0xFF] = SDLK_BREAK;
+	MISC_keymap[XK_Menu&0xFF] = SDLK_MENU;
+	MISC_keymap[XK_Hyper_R&0xFF] = SDLK_MENU;   /* Windows "Menu" key */
+}
+
+/* Get the translated SDL virtual keysym */
+SDLKey X11_TranslateKeycode(Display *display, KeyCode kc)
+{
+	KeySym xsym;
+	SDLKey key;
+
+	xsym = XKeycodeToKeysym(display, kc, 0);
+#ifdef DEBUG_KEYS
+	fprintf(stderr, "Translating key code %d -> 0x%.4x\n", kc, xsym);
+#endif
+	key = SDLK_UNKNOWN;
+	if ( xsym ) {
+		switch (xsym>>8) {
+		    case 0x1005FF:
+#ifdef SunXK_F36
+			if ( xsym == SunXK_F36 )
+				key = SDLK_F11;
+#endif
+#ifdef SunXK_F37
+			if ( xsym == SunXK_F37 )
+				key = SDLK_F12;
+#endif
+			break;
+		    case 0x00:	/* Latin 1 */
+			key = (SDLKey)(xsym & 0xFF);
+			break;
+		    case 0x01:	/* Latin 2 */
+		    case 0x02:	/* Latin 3 */
+		    case 0x03:	/* Latin 4 */
+		    case 0x04:	/* Katakana */
+		    case 0x05:	/* Arabic */
+		    case 0x06:	/* Cyrillic */
+		    case 0x07:	/* Greek */
+		    case 0x08:	/* Technical */
+		    case 0x0A:	/* Publishing */
+		    case 0x0C:	/* Hebrew */
+		    case 0x0D:	/* Thai */
+			/* These are wrong, but it's better than nothing */
+			key = (SDLKey)(xsym & 0xFF);
+			break;
+		    case 0xFE:
+			key = ODD_keymap[xsym&0xFF];
+			break;
+		    case 0xFF:
+			key = MISC_keymap[xsym&0xFF];
+			break;
+		    default:
+			/*
+			fprintf(stderr, "X11: Unhandled xsym, sym = 0x%04x\n",
+					(unsigned int)xsym);
+			*/
+			break;
+		}
+	} else {
+		/* X11 doesn't know how to translate the key! */
+		switch (kc) {
+		    /* Caution:
+		       These keycodes are from the Microsoft Keyboard
+		     */
+		    case 115:
+			key = SDLK_LSUPER;
+			break;
+		    case 116:
+			key = SDLK_RSUPER;
+			break;
+		    case 117:
+			key = SDLK_MENU;
+			break;
+		    default:
+			/*
+			 * no point in an error message; happens for
+			 * several keys when we get a keymap notify
+			 */
+			break;
+		}
+	}
+	return key;
+}
+
+/* X11 modifier masks for various keys */
+static unsigned meta_l_mask, meta_r_mask, alt_l_mask, alt_r_mask;
+static unsigned num_mask, mode_switch_mask;
+
+static void get_modifier_masks(Display *display)
+{
+	static unsigned got_masks;
+	int i, j;
+	XModifierKeymap *xmods;
+	unsigned n;
+
+	if(got_masks)
+		return;
+
+	xmods = XGetModifierMapping(display);
+	n = xmods->max_keypermod;
+	for(i = 3; i < 8; i++) {
+		for(j = 0; j < n; j++) {
+			KeyCode kc = xmods->modifiermap[i * n + j];
+			KeySym ks = XKeycodeToKeysym(display, kc, 0);
+			unsigned mask = 1 << i;
+			switch(ks) {
+			case XK_Num_Lock:
+				num_mask = mask; break;
+			case XK_Alt_L:
+				alt_l_mask = mask; break;
+			case XK_Alt_R:
+				alt_r_mask = mask; break;
+			case XK_Meta_L:
+				meta_l_mask = mask; break;
+			case XK_Meta_R:
+				meta_r_mask = mask; break;
+			case XK_Mode_switch:
+				mode_switch_mask = mask; break;
+			}
+		}
+	}
+	XFreeModifiermap(xmods);
+	got_masks = 1;
+}
+
+
+/*
+ * This function is semi-official; it is not officially exported and should
+ * not be considered part of the SDL API, but may be used by client code
+ * that *really* needs it (including legacy code).
+ * It is slow, though, and should be avoided if possible.
+ *
+ * Note that it isn't completely accurate either; in particular, multi-key
+ * sequences (dead accents, compose key sequences) will not work since the
+ * state has been irrevocably lost.
+ */
+extern DECLSPEC Uint16 SDLCALL X11_KeyToUnicode(SDLKey, SDLMod);
+
+Uint16 X11_KeyToUnicode(SDLKey keysym, SDLMod modifiers)
+{
+	static int warning = 1;
+	struct SDL_VideoDevice *this = current_video;
+	char keybuf[32];
+	int i;
+	KeySym xsym = 0;
+	XKeyEvent xkey;
+	Uint16 unicode;
+
+	if ( warning ) {
+		warning = 0;
+		fprintf(stderr, "WARNING: Application is using X11_KeyToUnicode().\n");
+		fprintf(stderr, "This is not an official SDL function, please report this as a bug.\n");
+	}
+
+	if ( !this || !SDL_Display ) {
+		return 0;
+	}
+
+	SDL_memset(&xkey, 0, sizeof(xkey));
+	xkey.display = SDL_Display;
+
+	xsym = keysym;		/* last resort if not found */
+	for (i = 0; i < 256; ++i) {
+		if ( MISC_keymap[i] == keysym ) {
+			xsym = 0xFF00 | i;
+			break;
+		} else if ( ODD_keymap[i] == keysym ) {
+			xsym = 0xFE00 | i;
+			break;
+		}
+	}
+
+	xkey.keycode = XKeysymToKeycode(xkey.display, xsym);
+
+	get_modifier_masks(SDL_Display);
+	if(modifiers & KMOD_SHIFT)
+		xkey.state |= ShiftMask;
+	if(modifiers & KMOD_CAPS)
+		xkey.state |= LockMask;
+	if(modifiers & KMOD_CTRL)
+		xkey.state |= ControlMask;
+	if(modifiers & KMOD_MODE)
+		xkey.state |= mode_switch_mask;
+	if(modifiers & KMOD_LALT)
+		xkey.state |= alt_l_mask;
+	if(modifiers & KMOD_RALT)
+		xkey.state |= alt_r_mask;
+	if(modifiers & KMOD_LMETA)
+		xkey.state |= meta_l_mask;
+	if(modifiers & KMOD_RMETA)
+		xkey.state |= meta_r_mask;
+	if(modifiers & KMOD_NUM)
+		xkey.state |= num_mask;
+
+	unicode = 0;
+	if ( XLookupString(&xkey, keybuf, sizeof(keybuf), NULL, NULL) )
+		unicode = (unsigned char)keybuf[0];
+	return(unicode);
+}
+
+
+/*
+ * Called when focus is regained, to read the keyboard state and generate
+ * synthetic keypress/release events.
+ * key_vec is a bit vector of keycodes (256 bits)
+ */
+void X11_SetKeyboardState(Display *display, const char *key_vec)
+{
+	char keys_return[32];
+	int i;
+	Uint8 *kstate = SDL_GetKeyState(NULL);
+	SDLMod modstate;
+	Window junk_window;
+	int x, y;
+	unsigned int mask;
+
+	/* The first time the window is mapped, we initialize key state */
+	if ( ! key_vec ) {
+		XQueryKeymap(display, keys_return);
+		key_vec = keys_return;
+	}
+
+	/* Get the keyboard modifier state */
+	modstate = 0;
+	get_modifier_masks(display);
+	if ( XQueryPointer(display, DefaultRootWindow(display),
+		&junk_window, &junk_window, &x, &y, &x, &y, &mask) ) {
+		if ( mask & LockMask ) {
+			modstate |= KMOD_CAPS;
+		}
+		if ( mask & mode_switch_mask ) {
+			modstate |= KMOD_MODE;
+		}
+		if ( mask & num_mask ) {
+			modstate |= KMOD_NUM;
+		}
+	}
+
+	/* Zero the new keyboard state and generate it */
+	SDL_memset(kstate, 0, SDLK_LAST);
+	/*
+	 * An obvious optimisation is to check entire longwords at a time in
+	 * both loops, but we can't be sure the arrays are aligned so it's not
+	 * worth the extra complexity
+	 */
+	for ( i = 0; i < 32; i++ ) {
+		int j;
+		if ( !key_vec[i] )
+			continue;
+		for ( j = 0; j < 8; j++ ) {
+			if ( key_vec[i] & (1 << j) ) {
+				SDLKey key;
+				KeyCode kc = (i << 3 | j);
+				key = X11_TranslateKeycode(display, kc);
+				if ( key == SDLK_UNKNOWN ) {
+					continue;
+				}
+				kstate[key] = SDL_PRESSED;
+				switch (key) {
+				    case SDLK_LSHIFT:
+					modstate |= KMOD_LSHIFT;
+					break;
+				    case SDLK_RSHIFT:
+					modstate |= KMOD_RSHIFT;
+					break;
+				    case SDLK_LCTRL:
+					modstate |= KMOD_LCTRL;
+					break;
+				    case SDLK_RCTRL:
+					modstate |= KMOD_RCTRL;
+					break;
+				    case SDLK_LALT:
+					modstate |= KMOD_LALT;
+					break;
+				    case SDLK_RALT:
+					modstate |= KMOD_RALT;
+					break;
+				    case SDLK_LMETA:
+					modstate |= KMOD_LMETA;
+					break;
+				    case SDLK_RMETA:
+					modstate |= KMOD_RMETA;
+					break;
+				    default:
+					break;
+				}
+			}
+		}
+	}
+
+	/* Hack - set toggle key state */
+	if ( modstate & KMOD_CAPS ) {
+		kstate[SDLK_CAPSLOCK] = SDL_PRESSED;
+	} else {
+		kstate[SDLK_CAPSLOCK] = SDL_RELEASED;
+	}
+	if ( modstate & KMOD_NUM ) {
+		kstate[SDLK_NUMLOCK] = SDL_PRESSED;
+	} else {
+		kstate[SDLK_NUMLOCK] = SDL_RELEASED;
+	}
+
+	/* Set the final modifier state */
+	SDL_SetModState(modstate);
+}
+
+void X11_InitOSKeymap(_THIS)
+{
+	X11_InitKeymap();
+}
+

=== added file '.pc/fix_window_resizing.diff/src/video/x11/SDL_x11events_c.h'
--- .pc/fix_window_resizing.diff/src/video/x11/SDL_x11events_c.h	1970-01-01 00:00:00 +0000
+++ .pc/fix_window_resizing.diff/src/video/x11/SDL_x11events_c.h	2015-06-01 21:40:05 +0000
@@ -0,0 +1,34 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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
+    [e-mail]
+*/
+#include "SDL_config.h"
+
+#include "SDL_x11video.h"
+
+/* Functions to be exported */
+extern void X11_InitOSKeymap(_THIS);
+extern void X11_PumpEvents(_THIS);
+extern void X11_SetKeyboardState(Display *display, const char *key_vec);
+
+/* Variables to be exported */
+extern int X11_PendingConfigureNotifyWidth;
+extern int X11_PendingConfigureNotifyHeight;
+

=== added file '.pc/fix_window_resizing.diff/src/video/x11/SDL_x11video.c'
--- .pc/fix_window_resizing.diff/src/video/x11/SDL_x11video.c	1970-01-01 00:00:00 +0000
+++ .pc/fix_window_resizing.diff/src/video/x11/SDL_x11video.c	2015-06-01 21:40:05 +0000
@@ -0,0 +1,1571 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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
+    [e-mail]
+*/
+#include "SDL_config.h"
+
+/* X11 based SDL video driver implementation.
+   Note:  This implementation does not currently need X11 thread locking,
+          since the event thread uses a separate X connection and any
+          additional locking necessary is handled internally.  However,
+          if full locking is neccessary, take a look at XInitThreads().
+*/
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+#ifdef MTRR_SUPPORT
+#include <asm/mtrr.h>
+#include <sys/fcntl.h>
+#endif
+
+#include "SDL_endian.h"
+#include "SDL_timer.h"
+#include "SDL_thread.h"
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+#include "SDL_x11video.h"
+#include "SDL_x11wm_c.h"
+#include "SDL_x11mouse_c.h"
+#include "SDL_x11events_c.h"
+#include "SDL_x11modes_c.h"
+#include "SDL_x11image_c.h"
+#include "SDL_x11yuv_c.h"
+#include "SDL_x11gl_c.h"
+#include "SDL_x11gamma_c.h"
+#include "../blank_cursor.h"
+
+#ifdef X_HAVE_UTF8_STRING
+#include <locale.h>
+#endif
+
+/* Initialization/Query functions */
+static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat);
+static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int X11_ToggleFullScreen(_THIS, int on);
+static void X11_UpdateMouse(_THIS);
+static int X11_SetColors(_THIS, int firstcolor, int ncolors,
+			 SDL_Color *colors);
+static int X11_SetGammaRamp(_THIS, Uint16 *ramp);
+static void X11_VideoQuit(_THIS);
+
+
+/* X11 driver bootstrap functions */
+
+static int X11_Available(void)
+{
+	Display *display = NULL;
+	if ( SDL_X11_LoadSymbols() ) {
+		display = XOpenDisplay(NULL);
+		if ( display != NULL ) {
+			XCloseDisplay(display);
+		}
+		SDL_X11_UnloadSymbols();
+	}
+	return(display != NULL);
+}
+
+static void X11_DeleteDevice(SDL_VideoDevice *device)
+{
+	if ( device ) {
+		if ( device->hidden ) {
+			SDL_free(device->hidden);
+		}
+		if ( device->gl_data ) {
+			SDL_free(device->gl_data);
+		}
+		SDL_free(device);
+		SDL_X11_UnloadSymbols();
+	}
+}
+
+static SDL_VideoDevice *X11_CreateDevice(int devindex)
+{
+	SDL_VideoDevice *device = NULL;
+
+	if ( SDL_X11_LoadSymbols() ) {
+		/* Initialize all variables that we clean on shutdown */
+		device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
+		if ( device ) {
+			SDL_memset(device, 0, (sizeof *device));
+			device->hidden = (struct SDL_PrivateVideoData *)
+					SDL_malloc((sizeof *device->hidden));
+			device->gl_data = (struct SDL_PrivateGLData *)
+					SDL_malloc((sizeof *device->gl_data));
+		}
+		if ( (device == NULL) || (device->hidden == NULL) ||
+		                         (device->gl_data == NULL) ) {
+			SDL_OutOfMemory();
+			X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */
+			return(0);
+		}
+		SDL_memset(device->hidden, 0, (sizeof *device->hidden));
+		SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
+
+#if SDL_VIDEO_OPENGL_GLX
+		device->gl_data->swap_interval = -1;
+#endif
+
+		/* Set the driver flags */
+		device->handles_any_size = 1;
+
+		/* Set the function pointers */
+		device->VideoInit = X11_VideoInit;
+		device->ListModes = X11_ListModes;
+		device->SetVideoMode = X11_SetVideoMode;
+		device->ToggleFullScreen = X11_ToggleFullScreen;
+		device->UpdateMouse = X11_UpdateMouse;
+#if SDL_VIDEO_DRIVER_X11_XV
+		device->CreateYUVOverlay = X11_CreateYUVOverlay;
+#endif
+		device->SetColors = X11_SetColors;
+		device->UpdateRects = NULL;
+		device->VideoQuit = X11_VideoQuit;
+		device->AllocHWSurface = X11_AllocHWSurface;
+		device->CheckHWBlit = NULL;
+		device->FillHWRect = NULL;
+		device->SetHWColorKey = NULL;
+		device->SetHWAlpha = NULL;
+		device->LockHWSurface = X11_LockHWSurface;
+		device->UnlockHWSurface = X11_UnlockHWSurface;
+		device->FlipHWSurface = X11_FlipHWSurface;
+		device->FreeHWSurface = X11_FreeHWSurface;
+		device->SetGamma = X11_SetVidModeGamma;
+		device->GetGamma = X11_GetVidModeGamma;
+		device->SetGammaRamp = X11_SetGammaRamp;
+		device->GetGammaRamp = NULL;
+#if SDL_VIDEO_OPENGL_GLX
+		device->GL_LoadLibrary = X11_GL_LoadLibrary;
+		device->GL_GetProcAddress = X11_GL_GetProcAddress;
+		device->GL_GetAttribute = X11_GL_GetAttribute;
+		device->GL_MakeCurrent = X11_GL_MakeCurrent;
+		device->GL_SwapBuffers = X11_GL_SwapBuffers;
+#endif
+		device->SetCaption = X11_SetCaption;
+		device->SetIcon = X11_SetIcon;
+		device->IconifyWindow = X11_IconifyWindow;
+		device->GrabInput = X11_GrabInput;
+		device->GetWMInfo = X11_GetWMInfo;
+		device->FreeWMCursor = X11_FreeWMCursor;
+		device->CreateWMCursor = X11_CreateWMCursor;
+		device->ShowWMCursor = X11_ShowWMCursor;
+		device->WarpWMCursor = X11_WarpWMCursor;
+		device->CheckMouseMode = X11_CheckMouseMode;
+		device->InitOSKeymap = X11_InitOSKeymap;
+		device->PumpEvents = X11_PumpEvents;
+
+		device->free = X11_DeleteDevice;
+	}
+
+	return device;
+}
+
+VideoBootStrap X11_bootstrap = {
+	"x11", "X Window System",
+	X11_Available, X11_CreateDevice
+};
+
+/* Normal X11 error handler routine */
+static int (*X_handler)(Display *, XErrorEvent *) = NULL;
+static int x_errhandler(Display *d, XErrorEvent *e)
+{
+#if SDL_VIDEO_DRIVER_X11_VIDMODE
+	extern int vm_error;
+#endif
+#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
+	extern int dga_error;
+#endif
+
+#if SDL_VIDEO_DRIVER_X11_VIDMODE
+	/* VidMode errors are non-fatal. :) */
+	/* Are the errors offset by one from the error base?
+	   e.g. the error base is 143, the code is 148, and the
+	        actual error is XF86VidModeExtensionDisabled (4) ?
+	 */
+        if ( (vm_error >= 0) &&
+	     (((e->error_code == BadRequest)&&(e->request_code == vm_error)) ||
+	      ((e->error_code > vm_error) &&
+	       (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) {
+#ifdef X11_DEBUG
+{ char errmsg[1024];
+  XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
+printf("VidMode error: %s\n", errmsg);
+}
+#endif
+        	return(0);
+        }
+#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
+
+#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
+	/* DGA errors can be non-fatal. :) */
+        if ( (dga_error >= 0) &&
+	     ((e->error_code > dga_error) &&
+	      (e->error_code <= (dga_error+XF86DGANumberErrors))) ) {
+#ifdef X11_DEBUG
+{ char errmsg[1024];
+  XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
+printf("DGA error: %s\n", errmsg);
+}
+#endif
+        	return(0);
+        }
+#endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */
+
+	return(X_handler(d,e));
+}
+
+/* X11 I/O error handler routine */
+static int (*XIO_handler)(Display *) = NULL;
+static int xio_errhandler(Display *d)
+{
+	/* Ack!  Lost X11 connection! */
+
+	/* We will crash if we try to clean up our display */
+	if ( SDL_VideoSurface && current_video->hidden->Ximage ) {
+		SDL_VideoSurface->pixels = NULL;
+	}
+	current_video->hidden->X11_Display = NULL;
+
+	/* Continue with the standard X11 error handler */
+	return(XIO_handler(d));
+}
+
+static int (*Xext_handler)(Display *, _Xconst char *, _Xconst char *) = NULL;
+static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason)
+{
+#ifdef X11_DEBUG
+	printf("Xext error inside SDL (may be harmless):\n");
+	printf("  Extension \"%s\" %s on display \"%s\".\n",
+	       ext, reason, XDisplayString(d));
+#endif
+
+	if (SDL_strcmp(reason, "missing") == 0) {
+		/*
+		 * Since the query itself, elsewhere, can handle a missing extension
+		 *  and the default behaviour in Xlib is to write to stderr, which
+		 *  generates unnecessary bug reports, we just ignore these.
+		 */
+		return 0;
+	}
+
+	/* Everything else goes to the default handler... */
+	return Xext_handler(d, ext, reason);
+}
+
+/* Find out what class name we should use */
+static char *get_classname(char *classname, int maxlen)
+{
+	char *spot;
+#if defined(__LINUX__) || defined(__FREEBSD__)
+	char procfile[1024];
+	char linkfile[1024];
+	int linksize;
+#endif
+
+	/* First allow environment variable override */
+	spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS");
+	if ( spot ) {
+		SDL_strlcpy(classname, spot, maxlen);
+		return classname;
+	}
+
+	/* Next look at the application's executable name */
+#if defined(__LINUX__) || defined(__FREEBSD__)
+#if defined(__LINUX__)
+	SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid());
+#elif defined(__FREEBSD__)
+	SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file", getpid());
+#else
+#error Where can we find the executable name?
+#endif
+	linksize = readlink(procfile, linkfile, sizeof(linkfile)-1);
+	if ( linksize > 0 ) {
+		linkfile[linksize] = '\0';
+		spot = SDL_strrchr(linkfile, '/');
+		if ( spot ) {
+			SDL_strlcpy(classname, spot+1, maxlen);
+		} else {
+			SDL_strlcpy(classname, linkfile, maxlen);
+		}
+		return classname;
+	}
+#endif /* __LINUX__ */
+
+	/* Finally use the default we've used forever */
+	SDL_strlcpy(classname, "SDL_App", maxlen);
+	return classname;
+}
+
+/* Create auxiliary (toplevel) windows with the current visual */
+static void create_aux_windows(_THIS)
+{
+    int x = 0, y = 0;
+    char classname[1024];
+    XSetWindowAttributes xattr;
+    XWMHints *hints;
+    unsigned long app_event_mask;
+    int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
+
+    /* Look up some useful Atoms */
+    WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);
+
+    /* Don't create any extra windows if we are being managed */
+    if ( SDL_windowid ) {
+	FSwindow = 0;
+	WMwindow = SDL_strtol(SDL_windowid, NULL, 0);
+        return;
+    }
+
+    if(FSwindow)
+	XDestroyWindow(SDL_Display, FSwindow);
+
+#if SDL_VIDEO_DRIVER_X11_XINERAMA
+    if ( use_xinerama ) {
+        x = xinerama_info.x_org;
+        y = xinerama_info.y_org;
+    }
+#endif
+    xattr.override_redirect = True;
+    xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
+    xattr.border_pixel = 0;
+    xattr.colormap = SDL_XColorMap;
+
+    FSwindow = XCreateWindow(SDL_Display, SDL_Root,
+                             x, y, 32, 32, 0,
+			     this->hidden->depth, InputOutput, SDL_Visual,
+			     CWOverrideRedirect | CWBackPixel | CWBorderPixel
+			     | CWColormap,
+			     &xattr);
+
+    XSelectInput(SDL_Display, FSwindow, StructureNotifyMask);
+
+    /* Tell KDE to keep the fullscreen window on top */
+    {
+	XEvent ev;
+	long mask;
+
+	SDL_memset(&ev, 0, sizeof(ev));
+	ev.xclient.type = ClientMessage;
+	ev.xclient.window = SDL_Root;
+	ev.xclient.message_type = XInternAtom(SDL_Display,
+					      "KWM_KEEP_ON_TOP", False);
+	ev.xclient.format = 32;
+	ev.xclient.data.l[0] = FSwindow;
+	ev.xclient.data.l[1] = CurrentTime;
+	mask = SubstructureRedirectMask;
+	XSendEvent(SDL_Display, SDL_Root, False, mask, &ev);
+    }
+
+    hints = NULL;
+    if(WMwindow) {
+	/* All window attributes must survive the recreation */
+	hints = XGetWMHints(SDL_Display, WMwindow);
+	XDestroyWindow(SDL_Display, WMwindow);
+    }
+
+    /* Create the window for windowed management */
+    /* (reusing the xattr structure above) */
+    WMwindow = XCreateWindow(SDL_Display, SDL_Root,
+                             x, y, 32, 32, 0,
+			     this->hidden->depth, InputOutput, SDL_Visual,
+			     CWBackPixel | CWBorderPixel | CWColormap,
+			     &xattr);
+
+    /* Set the input hints so we get keyboard input */
+    if(!hints) {
+	hints = XAllocWMHints();
+	hints->input = True;
+	hints->flags = InputHint;
+    }
+    XSetWMHints(SDL_Display, WMwindow, hints);
+    XFree(hints);
+    X11_SetCaptionNoLock(this, this->wm_title, this->wm_icon);
+
+    app_event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask
+	| PropertyChangeMask | StructureNotifyMask | KeymapStateMask;
+    XSelectInput(SDL_Display, WMwindow, app_event_mask);
+
+    /* Set the class hints so we can get an icon (AfterStep) */
+    get_classname(classname, sizeof(classname));
+    {
+	XClassHint *classhints;
+	classhints = XAllocClassHint();
+	if(classhints != NULL) {
+	    classhints->res_name = classname;
+	    classhints->res_class = classname;
+	    XSetClassHint(SDL_Display, WMwindow, classhints);
+	    XFree(classhints);
+	}
+    }
+
+	{
+		pid_t pid = getpid();
+		char hostname[256];
+
+		if (pid > 0 && gethostname(hostname, sizeof(hostname)) > -1) {
+			Atom _NET_WM_PID = XInternAtom(SDL_Display, "_NET_WM_PID", False);
+			Atom WM_CLIENT_MACHINE = XInternAtom(SDL_Display, "WM_CLIENT_MACHINE", False);
+			
+			hostname[sizeof(hostname)-1] = '\0';
+			XChangeProperty(SDL_Display, WMwindow, _NET_WM_PID, XA_CARDINAL, 32,
+					PropModeReplace, (unsigned char *)&pid, 1);
+			XChangeProperty(SDL_Display, WMwindow, WM_CLIENT_MACHINE, XA_STRING, 8,
+					PropModeReplace, (unsigned char *)hostname, SDL_strlen(hostname));
+		}
+	}
+
+	/* Setup the communication with the IM server */
+	/* create_aux_windows may be called several times against the same
+	   Display.  We should reuse the SDL_IM if one has been opened for
+	   the Display, so we should not simply reset SDL_IM here.  */
+
+	#ifdef X_HAVE_UTF8_STRING
+	if (SDL_X11_HAVE_UTF8) {
+		/* Discard obsolete resources if any.  */
+		if (SDL_IM != NULL && SDL_Display != XDisplayOfIM(SDL_IM)) {
+			/* Just a double check. I don't think this
+		           code is ever executed. */
+			SDL_SetError("display has changed while an IM is kept");
+			if (SDL_IC) {
+				XUnsetICFocus(SDL_IC);
+				XDestroyIC(SDL_IC);
+				SDL_IC = NULL;
+			}
+			XCloseIM(SDL_IM);
+			SDL_IM = NULL;
+		}
+
+		/* Open an input method.  */
+		if (SDL_IM == NULL) {
+			char *old_locale = NULL, *old_modifiers = NULL;
+			const char *p;
+			size_t n;
+			/* I'm not comfortable to do locale setup
+			   here.  However, we need C library locale
+			   (and xlib modifiers) to be set based on the
+			   user's preference to use XIM, and many
+			   existing game programs doesn't take care of
+			   users' locale preferences, so someone other
+			   than the game program should do it.
+			   Moreover, ones say that some game programs
+			   heavily rely on the C locale behaviour,
+			   e.g., strcol()'s, and we can't change the C
+			   library locale.  Given the situation, I
+			   couldn't find better place to do the
+			   job... */
+
+			/* Save the current (application program's)
+			   locale settings.  */
+			p = setlocale(LC_ALL, NULL);
+			if ( p ) {
+				n = SDL_strlen(p)+1;
+				old_locale = SDL_stack_alloc(char, n);
+				if ( old_locale ) {
+					SDL_strlcpy(old_locale, p, n);
+				}
+			}
+			p = XSetLocaleModifiers(NULL);
+			if ( p ) {
+				n = SDL_strlen(p)+1;
+				old_modifiers = SDL_stack_alloc(char, n);
+				if ( old_modifiers ) {
+					SDL_strlcpy(old_modifiers, p, n);
+				}
+			}
+
+			/* Fetch the user's preferences and open the
+			   input method with them.  */
+			setlocale(LC_ALL, "");
+			XSetLocaleModifiers("");
+			SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname);
+
+			/* Restore the application's locale settings
+			   so that we don't break the application's
+			   expected behaviour.  */
+			if ( old_locale ) {
+				/* We need to restore the C library
+				   locale first, since the
+				   interpretation of the X modifier
+				   may depend on it.  */
+				setlocale(LC_ALL, old_locale);
+				SDL_stack_free(old_locale);
+			}
+			if ( old_modifiers ) {
+				XSetLocaleModifiers(old_modifiers);
+				SDL_stack_free(old_modifiers);
+			}
+		}
+
+		/* Create a new input context for the new window just created.  */
+		if (SDL_IM == NULL) {
+			SDL_SetError("no input method could be opened");
+		} else {
+			if (SDL_IC != NULL) {
+				/* Discard the old IC before creating new one.  */
+			    XUnsetICFocus(SDL_IC);
+			    XDestroyIC(SDL_IC);
+			}
+			/* Theoretically we should check the current IM supports
+			   PreeditNothing+StatusNothing style (i.e., root window method)
+			   before creating the IC.  However, it is the bottom line method,
+			   and we supports any other options.  If the IM didn't support
+			   root window method, the following call fails, and SDL falls
+			   back to pre-XIM keyboard handling.  */
+			SDL_IC = pXCreateIC(SDL_IM,
+					XNClientWindow, WMwindow,
+					XNFocusWindow, WMwindow,
+					XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
+					XNResourceName, classname,
+					XNResourceClass, classname,
+					NULL);
+
+			if (SDL_IC == NULL) {
+				SDL_SetError("no input context could be created");
+				XCloseIM(SDL_IM);
+				SDL_IM = NULL;
+			} else {
+				/* We need to receive X events that an IM wants and to pass
+				   them to the IM through XFilterEvent. The set of events may
+				   vary depending on the IM implementation and the options
+				   specified through various routes. Although unlikely, the
+				   xlib specification allows IM to change the event requirement
+				   with its own circumstances, it is safe to call SelectInput
+				   whenever we re-create an IC.  */
+				unsigned long mask = 0;
+				char *ret = pXGetICValues(SDL_IC, XNFilterEvents, &mask, NULL);
+				if (ret != NULL) {
+					XUnsetICFocus(SDL_IC);
+					XDestroyIC(SDL_IC);
+					SDL_IC = NULL;
+					SDL_SetError("no input context could be created");
+					XCloseIM(SDL_IM);
+					SDL_IM = NULL;
+				} else {
+					XSelectInput(SDL_Display, WMwindow, app_event_mask | mask);
+					XSetICFocus(SDL_IC);
+				}
+			}
+		}
+	}
+	#endif
+
+	/* Allow the window to be deleted by the window manager */
+	XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
+}
+
+static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat)
+{
+	const char *env;
+	char *display;
+	int i;
+
+	/* Open the X11 display */
+	display = NULL;		/* Get it from DISPLAY environment variable */
+
+	if ( (SDL_strncmp(XDisplayName(display), ":", 1) == 0) ||
+	     (SDL_strncmp(XDisplayName(display), "unix:", 5) == 0) ) {
+		local_X11 = 1;
+	} else {
+		local_X11 = 0;
+	}
+	SDL_Display = XOpenDisplay(display);
+#if defined(__osf__) && defined(SDL_VIDEO_DRIVER_X11_DYNAMIC)
+	/* On Tru64 if linking without -lX11, it fails and you get following message.
+	 * Xlib: connection to ":0.0" refused by server
+	 * Xlib: XDM authorization key matches an existing client!
+	 *
+	 * It succeeds if retrying 1 second later
+	 * or if running xhost +localhost on shell.
+	 *
+	 */
+	if ( SDL_Display == NULL ) {
+		SDL_Delay(1000);
+		SDL_Display = XOpenDisplay(display);
+	}
+#endif
+	if ( SDL_Display == NULL ) {
+		SDL_SetError("Couldn't open X11 display");
+		return(-1);
+	}
+#ifdef X11_DEBUG
+	XSynchronize(SDL_Display, True);
+#endif
+
+	/* Create an alternate X display for graphics updates -- allows us
+	   to do graphics updates in a separate thread from event handling.
+	   Thread-safe X11 doesn't seem to exist.
+	 */
+	GFX_Display = XOpenDisplay(display);
+	if ( GFX_Display == NULL ) {
+		XCloseDisplay(SDL_Display);
+		SDL_Display = NULL;
+		SDL_SetError("Couldn't open X11 display");
+		return(-1);
+	}
+
+	/* Set the normal X error handler */
+	X_handler = XSetErrorHandler(x_errhandler);
+
+	/* Set the error handler if we lose the X display */
+	XIO_handler = XSetIOErrorHandler(xio_errhandler);
+
+	/* Set the X extension error handler */
+	Xext_handler = XSetExtensionErrorHandler(xext_errhandler);
+
+	/* use default screen (from $DISPLAY) */
+	SDL_Screen = DefaultScreen(SDL_Display);
+
+#ifndef NO_SHARED_MEMORY
+	/* Check for MIT shared memory extension */
+	use_mitshm = 0;
+	if ( local_X11 ) {
+		use_mitshm = XShmQueryExtension(SDL_Display);
+	}
+#endif /* NO_SHARED_MEMORY */
+
+	/* Get the available video modes */
+	if(X11_GetVideoModes(this) < 0) {
+		XCloseDisplay(GFX_Display);
+		GFX_Display = NULL;
+		XCloseDisplay(SDL_Display);
+		SDL_Display = NULL;
+	    return -1;
+	}
+
+	/* Determine the current screen size */
+	this->info.current_w = DisplayWidth(SDL_Display, SDL_Screen);
+	this->info.current_h = DisplayHeight(SDL_Display, SDL_Screen);
+
+	/* Determine the default screen depth:
+	   Use the default visual (or at least one with the same depth) */
+	SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen);
+	for(i = 0; i < this->hidden->nvisuals; i++)
+	    if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display,
+							      SDL_Screen))
+		break;
+	if(i == this->hidden->nvisuals) {
+	    /* default visual was useless, take the deepest one instead */
+	    i = 0;
+	}
+	SDL_Visual = this->hidden->visuals[i].visual;
+	if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) {
+	    SDL_XColorMap = SDL_DisplayColormap;
+	} else {
+	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
+					    SDL_Visual, AllocNone);
+	}
+	this->hidden->depth = this->hidden->visuals[i].depth;
+	vformat->BitsPerPixel = this->hidden->visuals[i].bpp;
+	if ( vformat->BitsPerPixel > 8 ) {
+		vformat->Rmask = SDL_Visual->red_mask;
+	  	vformat->Gmask = SDL_Visual->green_mask;
+	  	vformat->Bmask = SDL_Visual->blue_mask;
+	}
+	if ( this->hidden->depth == 32 ) {
+		vformat->Amask = (0xFFFFFFFF & ~(vformat->Rmask|vformat->Gmask|vformat->Bmask));
+	}
+	X11_SaveVidModeGamma(this);
+
+	/* Allow environment override of screensaver disable. */
+	env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
+	if ( env ) {
+		allow_screensaver = SDL_atoi(env);
+	} else {
+#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
+		allow_screensaver = 0;
+#else
+		allow_screensaver = 1;
+#endif
+	}
+
+	/* See if we have been passed a window to use */
+	SDL_windowid = SDL_getenv("SDL_WINDOWID");
+
+	/* Create the fullscreen and managed windows */
+	create_aux_windows(this);
+
+	/* Create the blank cursor */
+	SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
+					BLANK_CWIDTH, BLANK_CHEIGHT,
+						BLANK_CHOTX, BLANK_CHOTY);
+
+	/* Fill in some window manager capabilities */
+	this->info.wm_available = 1;
+
+	/* We're done! */
+	XFlush(SDL_Display);
+	return(0);
+}
+
+static void X11_DestroyWindow(_THIS, SDL_Surface *screen)
+{
+	/* Clean up OpenGL */
+	if ( screen ) {
+		screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
+	}
+	X11_GL_Shutdown(this);
+
+	if ( ! SDL_windowid ) {
+		/* Hide the managed window */
+		if ( WMwindow ) {
+			XUnmapWindow(SDL_Display, WMwindow);
+		}
+		if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
+			screen->flags &= ~SDL_FULLSCREEN;
+			X11_LeaveFullScreen(this);
+		}
+
+		/* Destroy the output window */
+		if ( SDL_Window ) {
+			XDestroyWindow(SDL_Display, SDL_Window);
+		}
+
+		/* Free the colormap entries */
+		if ( SDL_XPixels ) {
+			int numcolors;
+			unsigned long pixel;
+			numcolors = SDL_Visual->map_entries;
+			for ( pixel=0; pixel<numcolors; ++pixel ) {
+				while ( SDL_XPixels[pixel] > 0 ) {
+					XFreeColors(GFX_Display,
+						SDL_DisplayColormap,&pixel,1,0);
+					--SDL_XPixels[pixel];
+				}
+			}
+			SDL_free(SDL_XPixels);
+			SDL_XPixels = NULL;
+		} 
+
+		/* Free the graphics context */
+		if ( SDL_GC ) {
+			XFreeGC(SDL_Display, SDL_GC);
+			SDL_GC = 0;
+		}
+	}
+}
+
+static SDL_bool X11_WindowPosition(_THIS, int *x, int *y, int w, int h)
+{
+	const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
+	const char *center = SDL_getenv("SDL_VIDEO_CENTERED");
+	if ( window ) {
+		if ( SDL_sscanf(window, "%d,%d", x, y) == 2 ) {
+			return SDL_TRUE;
+		}
+		if ( SDL_strcmp(window, "center") == 0 ) {
+			center = window;
+		}
+	}
+	if ( center ) {
+		*x = (DisplayWidth(SDL_Display, SDL_Screen) - w)/2;
+		*y = (DisplayHeight(SDL_Display, SDL_Screen) - h)/2;
+		return SDL_TRUE;
+	}
+	return SDL_FALSE;
+}
+
+static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags)
+{
+	XSizeHints *hints;
+
+	hints = XAllocSizeHints();
+	if ( hints ) {
+		if (!(flags & SDL_RESIZABLE)) {
+			hints->min_width = hints->max_width = w;
+			hints->min_height = hints->max_height = h;
+			hints->flags = PMaxSize | PMinSize;
+		}
+		if ( flags & SDL_FULLSCREEN ) {
+			hints->x = 0;
+			hints->y = 0;
+			hints->flags |= USPosition;
+		} else
+		/* Center it, if desired */
+		if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) {
+			hints->flags |= USPosition;
+
+			/* Hints must be set before moving the window, otherwise an
+			   unwanted ConfigureNotify event will be issued */
+			XSetWMNormalHints(SDL_Display, WMwindow, hints);
+
+			XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y);
+
+			/* Flush the resize event so we don't catch it later */
+			XSync(SDL_Display, True);
+		}
+		XSetWMNormalHints(SDL_Display, WMwindow, hints);
+		XFree(hints);
+	}
+
+	/* Respect the window caption style */
+	if ( flags & SDL_NOFRAME ) {
+		SDL_bool set;
+		Atom WM_HINTS;
+
+		/* We haven't modified the window manager hints yet */
+		set = SDL_FALSE;
+
+		/* First try to set MWM hints */
+		WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
+		if ( WM_HINTS != None ) {
+			/* Hints used by Motif compliant window managers */
+			struct {
+				unsigned long flags;
+				unsigned long functions;
+				unsigned long decorations;
+				long input_mode;
+				unsigned long status;
+			} MWMHints = { (1L << 1), 0, 0, 0, 0 };
+
+			XChangeProperty(SDL_Display, WMwindow,
+			                WM_HINTS, WM_HINTS, 32,
+			                PropModeReplace,
+					(unsigned char *)&MWMHints,
+					sizeof(MWMHints)/sizeof(long));
+			set = SDL_TRUE;
+		}
+		/* Now try to set KWM hints */
+		WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
+		if ( WM_HINTS != None ) {
+			long KWMHints = 0;
+
+			XChangeProperty(SDL_Display, WMwindow,
+			                WM_HINTS, WM_HINTS, 32,
+			                PropModeReplace,
+					(unsigned char *)&KWMHints,
+					sizeof(KWMHints)/sizeof(long));
+			set = SDL_TRUE;
+		}
+		/* Now try to set GNOME hints */
+		WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
+		if ( WM_HINTS != None ) {
+			long GNOMEHints = 0;
+
+			XChangeProperty(SDL_Display, WMwindow,
+			                WM_HINTS, WM_HINTS, 32,
+			                PropModeReplace,
+					(unsigned char *)&GNOMEHints,
+					sizeof(GNOMEHints)/sizeof(long));
+			set = SDL_TRUE;
+		}
+		/* Finally set the transient hints if necessary */
+		if ( ! set ) {
+			XSetTransientForHint(SDL_Display, WMwindow, SDL_Root);
+		}
+	} else {
+		SDL_bool set;
+		Atom WM_HINTS;
+
+		/* We haven't modified the window manager hints yet */
+		set = SDL_FALSE;
+
+		/* First try to unset MWM hints */
+		WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
+		if ( WM_HINTS != None ) {
+			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
+			set = SDL_TRUE;
+		}
+		/* Now try to unset KWM hints */
+		WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
+		if ( WM_HINTS != None ) {
+			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
+			set = SDL_TRUE;
+		}
+		/* Now try to unset GNOME hints */
+		WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
+		if ( WM_HINTS != None ) {
+			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
+			set = SDL_TRUE;
+		}
+		/* Finally unset the transient hints if necessary */
+		if ( ! set ) {
+			XDeleteProperty(SDL_Display, WMwindow, XA_WM_TRANSIENT_FOR);
+		}
+	}
+}
+
+static int X11_CreateWindow(_THIS, SDL_Surface *screen,
+			    int w, int h, int bpp, Uint32 flags)
+{
+	int i, depth;
+	Visual *vis;
+	int vis_change;
+	Uint32 Amask;
+
+	/* If a window is already present, destroy it and start fresh */
+	if ( SDL_Window ) {
+		X11_DestroyWindow(this, screen);
+		switch_waiting = 0; /* Prevent jump back to now-meaningless state. */
+	}
+
+	/* See if we have been given a window id */
+	if ( SDL_windowid ) {
+		SDL_Window = SDL_strtol(SDL_windowid, NULL, 0);
+	} else {
+		SDL_Window = 0;
+	}
+
+	/* find out which visual we are going to use */
+	if ( flags & SDL_OPENGL ) {
+		XVisualInfo *vi;
+
+		vi = X11_GL_GetVisual(this);
+		if( !vi ) {
+			return -1;
+		}
+		vis = vi->visual;
+		depth = vi->depth;
+	} else if ( SDL_windowid ) {
+		XWindowAttributes a;
+
+		XGetWindowAttributes(SDL_Display, SDL_Window, &a);
+		vis = a.visual;
+		depth = a.depth;
+	} else {
+		for ( i = 0; i < this->hidden->nvisuals; i++ ) {
+			if ( this->hidden->visuals[i].bpp == bpp )
+				break;
+		}
+		if ( i == this->hidden->nvisuals ) {
+			SDL_SetError("No matching visual for requested depth");
+			return -1;	/* should never happen */
+		}
+		vis = this->hidden->visuals[i].visual;
+		depth = this->hidden->visuals[i].depth;
+	}
+#ifdef X11_DEBUG
+        printf("Choosing %s visual at %d bpp - %d colormap entries\n", vis->class == PseudoColor ? "PseudoColor" : (vis->class == TrueColor ? "TrueColor" : (vis->class == DirectColor ? "DirectColor" : "Unknown")), depth, vis->map_entries);
+#endif
+	vis_change = (vis != SDL_Visual);
+	SDL_Visual = vis;
+	this->hidden->depth = depth;
+
+	/* Allocate the new pixel format for this video mode */
+	if ( this->hidden->depth == 32 ) {
+		Amask = (0xFFFFFFFF & ~(vis->red_mask|vis->green_mask|vis->blue_mask));
+	} else {
+		Amask = 0;
+	}
+	if ( ! SDL_ReallocFormat(screen, bpp,
+			vis->red_mask, vis->green_mask, vis->blue_mask, Amask) ) {
+		return -1;
+	}
+
+	/* Create the appropriate colormap */
+	if ( SDL_XColorMap != SDL_DisplayColormap ) {
+		XFreeColormap(SDL_Display, SDL_XColorMap);
+	}
+	if ( SDL_Visual->class == PseudoColor ) {
+	    int ncolors;
+
+	    /* Allocate the pixel flags */
+	    ncolors = SDL_Visual->map_entries;
+	    SDL_XPixels = SDL_malloc(ncolors * sizeof(int));
+	    if(SDL_XPixels == NULL) {
+		SDL_OutOfMemory();
+		return -1;
+	    }
+	    SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels));
+
+	    /* always allocate a private colormap on non-default visuals */
+	    if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) {
+		flags |= SDL_HWPALETTE;
+	    }
+	    if ( flags & SDL_HWPALETTE ) {
+		screen->flags |= SDL_HWPALETTE;
+		SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
+		                                SDL_Visual, AllocAll);
+	    } else {
+		SDL_XColorMap = SDL_DisplayColormap;
+	    }
+	} else if ( SDL_Visual->class == DirectColor ) {
+
+	    /* Create a colormap which we can manipulate for gamma */
+	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
+		                            SDL_Visual, AllocAll);
+            XSync(SDL_Display, False);
+
+	    /* Initialize the colormap to the identity mapping */
+	    SDL_GetGammaRamp(0, 0, 0);
+	    this->screen = screen;
+	    X11_SetGammaRamp(this, this->gamma);
+	    this->screen = NULL;
+	} else {
+	    /* Create a read-only colormap for our window */
+	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
+	                                    SDL_Visual, AllocNone);
+	}
+
+	/* Recreate the auxiliary windows, if needed (required for GL) */
+	if ( vis_change )
+	    create_aux_windows(this);
+
+	if(screen->flags & SDL_HWPALETTE) {
+	    /* Since the full-screen window might have got a nonzero background
+	       colour (0 is white on some displays), we should reset the
+	       background to 0 here since that is what the user expects
+	       with a private colormap */
+	    XSetWindowBackground(SDL_Display, FSwindow, 0);
+	    XClearWindow(SDL_Display, FSwindow);
+	}
+
+	/* resize the (possibly new) window manager window */
+	if( !SDL_windowid ) {
+	        X11_SetSizeHints(this, w, h, flags);
+		window_w = w;
+		window_h = h;
+		XResizeWindow(SDL_Display, WMwindow, w, h);
+	}
+
+	/* Create (or use) the X11 display window */
+	if ( !SDL_windowid ) {
+		if ( flags & SDL_OPENGL ) {
+			if ( X11_GL_CreateWindow(this, w, h) < 0 ) {
+				return(-1);
+			}
+		} else {
+			XSetWindowAttributes swa;
+
+			swa.background_pixel = 0;
+			swa.border_pixel = 0;
+			swa.colormap = SDL_XColorMap;
+			SDL_Window = XCreateWindow(SDL_Display, WMwindow,
+		                           	0, 0, w, h, 0, depth,
+		                           	InputOutput, SDL_Visual,
+		                           	CWBackPixel | CWBorderPixel
+		                           	| CWColormap, &swa);
+		}
+		/* Only manage our input if we own the window */
+		XSelectInput(SDL_Display, SDL_Window,
+					( EnterWindowMask | LeaveWindowMask
+					| ButtonPressMask | ButtonReleaseMask
+					| PointerMotionMask | ExposureMask ));
+	}
+	/* Create the graphics context here, once we have a window */
+	if ( flags & SDL_OPENGL ) {
+		if ( X11_GL_CreateContext(this) < 0 ) {
+			return(-1);
+		} else {
+			screen->flags |= SDL_OPENGL;
+		}
+	} else {
+		XGCValues gcv;
+
+		gcv.graphics_exposures = False;
+		SDL_GC = XCreateGC(SDL_Display, SDL_Window,
+		                   GCGraphicsExposures, &gcv);
+		if ( ! SDL_GC ) {
+			SDL_SetError("Couldn't create graphics context");
+			return(-1);
+		}
+	}
+
+	/* Set our colormaps when not setting a GL mode */
+	if ( ! (flags & SDL_OPENGL) ) {
+		XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
+		if( !SDL_windowid ) {
+		    XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap);
+		    XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap);
+		}
+	}
+
+#if 0 /* This is an experiment - are the graphics faster now? - nope. */
+	if ( SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE") )
+#endif
+	/* Cache the window in the server, when possible */
+	{
+		Screen *xscreen;
+		XSetWindowAttributes a;
+
+		xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen);
+		a.backing_store = DoesBackingStore(xscreen);
+		if ( a.backing_store != NotUseful ) {
+			XChangeWindowAttributes(SDL_Display, SDL_Window,
+			                        CWBackingStore, &a);
+		}
+	}
+
+	/* Map them both and go fullscreen, if requested */
+	if ( ! SDL_windowid ) {
+		XMapWindow(SDL_Display, SDL_Window);
+		XMapWindow(SDL_Display, WMwindow);
+		X11_WaitMapped(this, WMwindow);
+		if ( flags & SDL_FULLSCREEN ) {
+			screen->flags |= SDL_FULLSCREEN;
+			X11_EnterFullScreen(this);
+		} else {
+			screen->flags &= ~SDL_FULLSCREEN;
+		}
+	}
+	
+	return(0);
+}
+
+static int X11_ResizeWindow(_THIS,
+			SDL_Surface *screen, int w, int h, Uint32 flags)
+{
+	if ( ! SDL_windowid ) {
+		/* Resize the window manager window */
+		X11_SetSizeHints(this, w, h, flags);
+		window_w = w;
+		window_h = h;
+		XResizeWindow(SDL_Display, WMwindow, w, h);
+
+		/* Resize the fullscreen and display windows */
+		if ( flags & SDL_FULLSCREEN ) {
+			if ( screen->flags & SDL_FULLSCREEN ) {
+				X11_ResizeFullScreen(this);
+			} else {
+				screen->flags |= SDL_FULLSCREEN;
+				X11_EnterFullScreen(this);
+			}
+		} else {
+			if ( screen->flags & SDL_FULLSCREEN ) {
+				screen->flags &= ~SDL_FULLSCREEN;
+				X11_LeaveFullScreen(this);
+			}
+		}
+		XResizeWindow(SDL_Display, SDL_Window, w, h);
+	}
+	return(0);
+}
+
+SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current,
+				int width, int height, int bpp, Uint32 flags)
+{
+	Uint32 saved_flags;
+
+	/* Lock the event thread, in multi-threading environments */
+	SDL_Lock_EventThread();
+
+	/* Check the combination of flags we were passed */
+	if ( flags & SDL_FULLSCREEN ) {
+		/* Clear fullscreen flag if not supported */
+		if ( SDL_windowid ) {
+			flags &= ~SDL_FULLSCREEN;
+		}
+	}
+
+	/* Flush any delayed updates */
+	XSync(GFX_Display, False);
+
+	/* Set up the X11 window */
+	saved_flags = current->flags;
+	if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL))
+	      && (bpp == current->format->BitsPerPixel)
+          && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) {
+		if (X11_ResizeWindow(this, current, width, height, flags) < 0) {
+			current = NULL;
+			goto done;
+		}
+		X11_PendingConfigureNotifyWidth = width;
+		X11_PendingConfigureNotifyHeight = height;
+	} else {
+		if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) {
+			current = NULL;
+			goto done;
+		}
+	}
+
+	/* Update the internal keyboard state */
+	X11_SetKeyboardState(SDL_Display, NULL);
+
+	/* When the window is first mapped, ignore non-modifier keys */
+	if ( !current->w && !current->h ) {
+		Uint8 *keys = SDL_GetKeyState(NULL);
+		int i;
+		for ( i = 0; i < SDLK_LAST; ++i ) {
+			switch (i) {
+			    case SDLK_NUMLOCK:
+			    case SDLK_CAPSLOCK:
+			    case SDLK_LCTRL:
+			    case SDLK_RCTRL:
+			    case SDLK_LSHIFT:
+			    case SDLK_RSHIFT:
+			    case SDLK_LALT:
+			    case SDLK_RALT:
+			    case SDLK_LMETA:
+			    case SDLK_RMETA:
+			    case SDLK_MODE:
+				break;
+			    default:
+				keys[i] = SDL_RELEASED;
+				break;
+			}
+		}
+	}
+
+	/* Set up the new mode framebuffer */
+	if ( ((current->w != width) || (current->h != height)) ||
+             ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) {
+		current->w = width;
+		current->h = height;
+		current->pitch = SDL_CalculatePitch(current);
+		if (X11_ResizeImage(this, current, flags) < 0) {
+			current = NULL;
+			goto done;
+		}
+	}
+
+	/* Clear these flags and set them only if they are in the new set. */
+	current->flags &= ~(SDL_RESIZABLE|SDL_NOFRAME);
+	current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME));
+
+  done:
+	/* Release the event thread */
+	XSync(SDL_Display, False);
+	SDL_Unlock_EventThread();
+
+	/* We're done! */
+	return(current);
+}
+
+static int X11_ToggleFullScreen(_THIS, int on)
+{
+	Uint32 event_thread;
+
+	/* Don't switch if we don't own the window */
+	if ( SDL_windowid ) {
+		return(0);
+	}
+
+	/* Don't lock if we are the event thread */
+	event_thread = SDL_EventThreadID();
+	if ( event_thread && (SDL_ThreadID() == event_thread) ) {
+		event_thread = 0;
+	}
+	if ( event_thread ) {
+		SDL_Lock_EventThread();
+	}
+	if ( on ) {
+		this->screen->flags |= SDL_FULLSCREEN;
+		X11_EnterFullScreen(this);
+	} else {
+		this->screen->flags &= ~SDL_FULLSCREEN;
+		X11_LeaveFullScreen(this);
+	}
+	X11_RefreshDisplay(this);
+	if ( event_thread ) {
+		SDL_Unlock_EventThread();
+	}
+	SDL_ResetKeyboard();
+	return(1);
+}
+
+/* Update the current mouse state and position */
+static void X11_UpdateMouse(_THIS)
+{
+	Window u1; int u2;
+	Window current_win;
+	int x, y;
+	unsigned int mask;
+
+	/* Lock the event thread, in multi-threading environments */
+	SDL_Lock_EventThread();
+	if ( XQueryPointer(SDL_Display, SDL_Window, &u1, &current_win,
+	                   &u2, &u2, &x, &y, &mask) ) {
+		if ( (x >= 0) && (x < SDL_VideoSurface->w) &&
+		     (y >= 0) && (y < SDL_VideoSurface->h) ) {
+			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
+			SDL_PrivateMouseMotion(0, 0, x, y);
+		} else {
+			SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
+		}
+	}
+	SDL_Unlock_EventThread();
+}
+
+/* simple colour distance metric. Supposed to be better than a plain
+   Euclidian distance anyway. */
+#define COLOUR_FACTOR 3
+#define LIGHT_FACTOR 1
+#define COLOUR_DIST(r1, g1, b1, r2, g2, b2)				\
+	(COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2))	\
+	 + LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2)))
+
+static void allocate_nearest(_THIS, SDL_Color *colors,
+			     SDL_Color *want, int nwant)
+{
+	/*
+	 * There is no way to know which ones to choose from, so we retrieve
+	 * the entire colormap and try the nearest possible, until we find one
+	 * that is shared.
+	 */
+	XColor all[256];
+	int i;
+	for(i = 0; i < 256; i++)
+		all[i].pixel = i;
+	/* 
+	 * XQueryColors sets the flags in the XColor struct, so we use
+	 * that to keep track of which colours are available
+	 */
+	XQueryColors(GFX_Display, SDL_XColorMap, all, 256);
+
+	for(i = 0; i < nwant; i++) {
+		XColor *c;
+		int j;
+		int best = 0;
+		int mindist = 0x7fffffff;
+		int ri = want[i].r;
+		int gi = want[i].g;
+		int bi = want[i].b;
+		for(j = 0; j < 256; j++) {
+			int rj, gj, bj, d2;
+			if(!all[j].flags)
+				continue;	/* unavailable colour cell */
+			rj = all[j].red >> 8;
+			gj = all[j].green >> 8;
+			bj = all[j].blue >> 8;
+			d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj);
+			if(d2 < mindist) {
+				mindist = d2;
+				best = j;
+			}
+		}
+		if(SDL_XPixels[best])
+			continue; /* already allocated, waste no more time */
+		c = all + best;
+		if(XAllocColor(GFX_Display, SDL_XColorMap, c)) {
+			/* got it */
+			colors[c->pixel].r = c->red >> 8;
+			colors[c->pixel].g = c->green >> 8;
+			colors[c->pixel].b = c->blue >> 8;
+			++SDL_XPixels[c->pixel];
+		} else {
+			/* 
+			 * The colour couldn't be allocated, probably being
+			 * owned as a r/w cell by another client. Flag it as
+			 * unavailable and try again. The termination of the
+			 * loop is guaranteed since at least black and white
+			 * are always there.
+			 */
+			c->flags = 0;
+			i--;
+		}
+	}
+}
+
+int X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+{
+	int nrej = 0;
+
+	/* Check to make sure we have a colormap allocated */
+	if ( SDL_XPixels == NULL ) {
+		return(0);
+	}
+	if ( (this->screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) {
+	        /* private writable colormap: just set the colours we need */
+	        XColor  *xcmap;
+		int i;
+	        xcmap = SDL_stack_alloc(XColor, ncolors);
+		if(xcmap == NULL)
+		        return 0;
+		for ( i=0; i<ncolors; ++i ) {
+			xcmap[i].pixel = i + firstcolor;
+			xcmap[i].red   = (colors[i].r<<8)|colors[i].r;
+			xcmap[i].green = (colors[i].g<<8)|colors[i].g;
+			xcmap[i].blue  = (colors[i].b<<8)|colors[i].b;
+			xcmap[i].flags = (DoRed|DoGreen|DoBlue);
+		}
+		XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
+		XSync(GFX_Display, False);
+		SDL_stack_free(xcmap);
+	} else {
+	        /*
+		 * Shared colormap: We only allocate read-only cells, which
+		 * increases the likelyhood of colour sharing with other
+		 * clients. The pixel values will almost certainly be
+		 * different from the requested ones, so the user has to
+		 * walk the colormap and see which index got what colour.
+		 *
+		 * We can work directly with the logical palette since it
+		 * has already been set when we get here.
+		 */
+		SDL_Color *want, *reject;
+	        unsigned long *freelist;
+		int i;
+		int nfree = 0;
+		int nc = this->screen->format->palette->ncolors;
+	        colors = this->screen->format->palette->colors;
+		freelist = SDL_stack_alloc(unsigned long, nc);
+		/* make sure multiple allocations of the same cell are freed */
+	        for(i = 0; i < ncolors; i++) {
+		        int pixel = firstcolor + i;
+		        while(SDL_XPixels[pixel]) {
+			        freelist[nfree++] = pixel;
+				--SDL_XPixels[pixel];
+			}
+		}
+		XFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0);
+		SDL_stack_free(freelist);
+
+		want = SDL_stack_alloc(SDL_Color, ncolors);
+		reject = SDL_stack_alloc(SDL_Color, ncolors);
+		SDL_memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color));
+		/* make sure the user isn't fooled by her own wishes
+		   (black is safe, always available in the default colormap) */
+		SDL_memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color));
+
+		/* now try to allocate the colours */
+		for(i = 0; i < ncolors; i++) {
+		        XColor col;
+			col.red = want[i].r << 8;
+			col.green = want[i].g << 8;
+			col.blue = want[i].b << 8;
+			col.flags = DoRed | DoGreen | DoBlue;
+			if(XAllocColor(GFX_Display, SDL_XColorMap, &col)) {
+			        /* We got the colour, or at least the nearest
+				   the hardware could get. */
+			        colors[col.pixel].r = col.red >> 8;
+				colors[col.pixel].g = col.green >> 8;
+				colors[col.pixel].b = col.blue >> 8;
+				++SDL_XPixels[col.pixel];
+			} else {
+				/*
+				 * no more free cells, add it to the list
+				 * of rejected colours
+				 */
+				reject[nrej++] = want[i];
+			}
+		}
+		if(nrej)
+			allocate_nearest(this, colors, reject, nrej);
+		SDL_stack_free(reject);
+		SDL_stack_free(want);
+	}
+	return nrej == 0;
+}
+
+int X11_SetGammaRamp(_THIS, Uint16 *ramp)
+{
+	int i, ncolors;
+	XColor xcmap[256];
+
+	/* See if actually setting the gamma is supported */
+	if ( SDL_Visual->class != DirectColor ) {
+	    SDL_SetError("Gamma correction not supported on this visual");
+	    return(-1);
+	}
+
+	/* Calculate the appropriate palette for the given gamma ramp */
+	ncolors = SDL_Visual->map_entries;
+	for ( i=0; i<ncolors; ++i ) {
+		Uint8 c = (256 * i / ncolors);
+		xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
+		xcmap[i].red   = ramp[0*256+c];
+		xcmap[i].green = ramp[1*256+c];
+		xcmap[i].blue  = ramp[2*256+c];
+		xcmap[i].flags = (DoRed|DoGreen|DoBlue);
+	}
+	XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
+	XSync(GFX_Display, False);
+	return(0);
+}
+
+/* Note:  If we are terminated, this could be called in the middle of
+   another SDL video routine -- notably UpdateRects.
+*/
+void X11_VideoQuit(_THIS)
+{
+	/* Shutdown everything that's still up */
+	/* The event thread should be done, so we can touch SDL_Display */
+	if ( SDL_Display != NULL ) {
+		/* Flush any delayed updates */
+		XSync(GFX_Display, False);
+
+		/* Close the connection with the IM server */
+		#ifdef X_HAVE_UTF8_STRING
+		if (SDL_IC != NULL) {
+			XUnsetICFocus(SDL_IC);
+			XDestroyIC(SDL_IC);
+			SDL_IC = NULL;
+		}
+		if (SDL_IM != NULL) {
+			XCloseIM(SDL_IM);
+			SDL_IM = NULL;
+		}
+		#endif
+
+		/* Start shutting down the windows */
+		X11_DestroyImage(this, this->screen);
+		X11_DestroyWindow(this, this->screen);
+		X11_FreeVideoModes(this);
+		if ( SDL_XColorMap != SDL_DisplayColormap ) {
+			XFreeColormap(SDL_Display, SDL_XColorMap);
+		}
+		if ( SDL_iconcolors ) {
+			unsigned long pixel;
+			Colormap dcmap = DefaultColormap(SDL_Display,
+							 SDL_Screen);
+			for(pixel = 0; pixel < 256; ++pixel) {
+				while(SDL_iconcolors[pixel] > 0) {
+					XFreeColors(GFX_Display,
+						    dcmap, &pixel, 1, 0);
+					--SDL_iconcolors[pixel];
+				}
+			}
+			SDL_free(SDL_iconcolors);
+			SDL_iconcolors = NULL;
+		} 
+
+		/* Restore gamma settings if they've changed */
+		if ( SDL_GetAppState() & SDL_APPACTIVE ) {
+			X11_SwapVidModeGamma(this);
+		}
+
+		/* Free that blank cursor */
+		if ( SDL_BlankCursor != NULL ) {
+			this->FreeWMCursor(this, SDL_BlankCursor);
+			SDL_BlankCursor = NULL;
+		}
+
+		/* Close the X11 graphics connection */
+		if ( GFX_Display != NULL ) {
+			XCloseDisplay(GFX_Display);
+			GFX_Display = NULL;
+		}
+
+		/* Close the X11 display connection */
+		XCloseDisplay(SDL_Display);
+		SDL_Display = NULL;
+
+		/* Reset the X11 error handlers */
+		if ( XIO_handler ) {
+			XSetIOErrorHandler(XIO_handler);
+		}
+		if ( X_handler ) {
+			XSetErrorHandler(X_handler);
+		}
+
+		/* Unload GL library after X11 shuts down */
+		X11_GL_UnloadLibrary(this);
+	}
+	if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) {
+		/* Direct screen access, no memory buffer */
+		this->screen->pixels = NULL;