--- a/src/video/x11/SDL_x11video.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/x11/SDL_x11video.c	Sun May 28 13:04:16 2006 +0000
@@ -55,1086 +55,1126 @@
 #include "../blank_cursor.h"
 
 /* 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);
+static int X11_VideoInit (_THIS);
+static SDL_Surface *X11_SetVideoMode (_THIS, SDL_Surface * current,
+                                      const SDL_DisplayMode * mode,
+                                      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)
+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);
+    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)
+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();
-	}
+    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)
+static SDL_VideoDevice *
+X11_CreateDevice (int devindex)
 {
-	SDL_VideoDevice *device = NULL;
+    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_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));
 
-		/* Set the driver flags */
-		device->handles_any_size = 1;
+        /* 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;
+        /* Set the function pointers */
+        device->VideoInit = X11_VideoInit;
+        device->SetVideoMode = X11_SetVideoMode;
+        device->ToggleFullScreen = X11_ToggleFullScreen;
+        device->UpdateMouse = X11_UpdateMouse;
 #if SDL_VIDEO_DRIVER_X11_XV
-		device->CreateYUVOverlay = X11_CreateYUVOverlay;
+        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;
+        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;
+        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->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;
-	}
+        device->free = X11_DeleteDevice;
+    }
 
-	return device;
+    return device;
 }
 
 VideoBootStrap X11_bootstrap = {
-	"x11", "X Window System",
-	X11_Available, X11_CreateDevice
+    "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)
+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;
+    extern int vm_error;
 #endif
 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE
-	extern int dga_error;
+    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)))) ) {
+    /* 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);
-}
+        {
+            char errmsg[1024];
+            XGetErrorText (d, e->error_code, errmsg, sizeof (errmsg));
+            printf ("VidMode error: %s\n", errmsg);
+        }
 #endif
-        	return(0);
-        }
+        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))) ) {
+    /* 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);
-}
+        {
+            char errmsg[1024];
+            XGetErrorText (d, e->error_code, errmsg, sizeof (errmsg));
+            printf ("DGA error: %s\n", errmsg);
+        }
 #endif
-        	return(0);
-        }
+        return (0);
+    }
 #endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */
 
-	return(X_handler(d,e));
+    return (X_handler (d, e));
 }
 
 /* X11 I/O error handler routine */
-static int (*XIO_handler)(Display *) = NULL;
-static int xio_errhandler(Display *d)
+static int (*XIO_handler) (Display *) = NULL;
+static int
+xio_errhandler (Display * d)
 {
-	/* Ack!  Lost X11 connection! */
+    /* Ack!  Lost X11 connection! */
 
-	/* We will crash if we try to clean up our display */
-	if ( current_video->hidden->Ximage ) {
-		SDL_VideoSurface->pixels = NULL;
-	}
-	current_video->hidden->X11_Display = NULL;
+    /* We will crash if we try to clean up our display */
+    if (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));
+    /* 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)
+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));
+    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;
-	}
+    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);
+    /* 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)
+static char *
+get_classname (char *classname, int maxlen)
 {
-	char *spot;
+    char *spot;
 #if defined(__LINUX__) || defined(__FREEBSD__)
-	char procfile[1024];
-	char linkfile[1024];
-	int linksize;
+    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;
-	}
+    /* 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 */
+    /* 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());
+    SDL_snprintf (procfile, SDL_arraysize (procfile), "/proc/%d/exe",
+                  getpid ());
 #elif defined(__FREEBSD__)
-	SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file", getpid());
+    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;
-	}
+    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;
+    /* 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)
+static void
+create_aux_windows (_THIS)
 {
     int x = 0, y = 0;
     char classname[1024];
     XSetWindowAttributes xattr;
     XWMHints *hints;
-    int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
+    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);
+    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);
+    if (SDL_windowid) {
+        FSwindow = 0;
+        WMwindow = SDL_strtol (SDL_windowid, NULL, 0);
         return;
     }
 
-    if(FSwindow)
-	XDestroyWindow(SDL_Display, FSwindow);
+    if (FSwindow)
+        XDestroyWindow (SDL_Display, FSwindow);
 
 #if SDL_VIDEO_DRIVER_X11_VIDMODE
-    if ( use_xinerama ) {
-        x = xinerama_info.x_org;
-        y = xinerama_info.y_org;
+    if (use_xinerama) {
+        x = xinerama[this->current_display].x_org;
+        y = xinerama[this->current_display].y_org;
     }
 #endif
     xattr.override_redirect = True;
-    xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
+    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);
+    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);
+    XSelectInput (SDL_Display, FSwindow, StructureNotifyMask);
 
     /* Tell KDE to keep the fullscreen window on top */
     {
-	XEvent ev;
-	long mask;
+        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);
+        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);
+    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);
+    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;
+    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);
+    XSetWMHints (SDL_Display, WMwindow, hints);
+    XFree (hints);
+    X11_SetCaptionNoLock (this, SDL_CurrentWindow.wm_title,
+                          SDL_CurrentWindow.wm_icon);
 
-    XSelectInput(SDL_Display, WMwindow,
-		 FocusChangeMask | KeyPressMask | KeyReleaseMask
-		 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask);
+    XSelectInput (SDL_Display, WMwindow,
+                  FocusChangeMask | KeyPressMask | KeyReleaseMask
+                  | PropertyChangeMask | StructureNotifyMask |
+                  KeymapStateMask);
 
     /* Set the class hints so we can get an icon (AfterStep) */
-    get_classname(classname, sizeof(classname));
+    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);
-	}
+        XClassHint *classhints;
+        classhints = XAllocClassHint ();
+        if (classhints != NULL) {
+            classhints->res_name = classname;
+            classhints->res_class = classname;
+            XSetClassHint (SDL_Display, WMwindow, classhints);
+            XFree (classhints);
+        }
     }
 
     /* Setup the communication with the IM server */
-	SDL_IM = NULL;
-	SDL_IC = NULL;
+    SDL_IM = NULL;
+    SDL_IC = NULL;
 
-	#ifdef X_HAVE_UTF8_STRING
-	if (SDL_X11_HAVE_UTF8) {
-		SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname);
-		if (SDL_IM == NULL) {
-			SDL_SetError("no input method could be opened");
-		} else {
-			SDL_IC = pXCreateIC(SDL_IM,
-					XNClientWindow, WMwindow,
-					XNFocusWindow, WMwindow,
-					XNInputStyle, XIMPreeditNothing  | XIMStatusNothing,
-					XNResourceName, classname,
-					XNResourceClass, classname,
-					NULL);
+#ifdef X_HAVE_UTF8_STRING
+    if (SDL_X11_HAVE_UTF8) {
+        SDL_IM = XOpenIM (SDL_Display, NULL, classname, classname);
+        if (SDL_IM == NULL) {
+            SDL_SetError ("no input method could be opened");
+        } else {
+            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;
-			}
-		}
-	}
-	#endif
+            if (SDL_IC == NULL) {
+                SDL_SetError ("no input context could be created");
+                XCloseIM (SDL_IM);
+                SDL_IM = NULL;
+            }
+        }
+    }
+#endif
 
-	/* Allow the window to be deleted by the window manager */
-	XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
+    /* 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)
+static int
+X11_VideoInit (_THIS)
 {
-	char *display;
-	int i;
-
-	/* Open the X11 display */
-	display = NULL;		/* Get it from DISPLAY environment variable */
+    char *display;
+    int i;
+    SDL_DisplayMode desktop_mode;
 
-	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);
+    /* 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);
-	}
+    /* 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);
-	}
+    if (SDL_Display == NULL) {
+        SDL_SetError ("Couldn't open X11 display");
+        return (-1);
+    }
 #ifdef X11_DEBUG
-	XSynchronize(SDL_Display, True);
+    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 ) {
-		SDL_SetError("Couldn't open X11 display");
-		return(-1);
-	}
+    /* 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) {
+        SDL_SetError ("Couldn't open X11 display");
+        return (-1);
+    }
 
-	/* Set the normal X error handler */
-	X_handler = XSetErrorHandler(x_errhandler);
+    /* 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 error handler if we lose the X display */
+    XIO_handler = XSetIOErrorHandler (xio_errhandler);
 
-	/* Set the X extension error handler */
-	Xext_handler = XSetExtensionErrorHandler(xext_errhandler);
+    /* Set the X extension error handler */
+    Xext_handler = XSetExtensionErrorHandler (xext_errhandler);
 
-	/* use default screen (from $DISPLAY) */
-	SDL_Screen = DefaultScreen(SDL_Display);
+    /* 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);
-	}
+    /* 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)
-	    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);
+    /* Get the available visuals */
+    if (X11_GetVisuals (this) < 0)
+        return -1;
 
-	/* 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);
+    /* Determine the default screen mode:
+       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);
+    }
+    desktop_mode.format =
+        X11_VisualToFormat (this->hidden->visuals[i].visual,
+                            this->hidden->visuals[i].depth,
+                            this->hidden->visuals[i].bpp);
+    desktop_mode.w = DisplayWidth (SDL_Display, SDL_Screen);
+    desktop_mode.h = DisplayHeight (SDL_Display, SDL_Screen);
+    desktop_mode.refresh_rate = 0;
+    SDL_AddVideoDisplay (&desktop_mode);
 
-	/* Save DPMS and screensaver settings */
-	X11_SaveScreenSaver(SDL_Display, &screensaver_timeout, &dpms_enabled);
-	X11_DisableScreenSaver(SDL_Display);
+    /* Get the available video modes */
+    if (X11_GetVideoModes (this) < 0)
+        return -1;
+
+    X11_SaveVidModeGamma (this);
 
-	/* See if we have been passed a window to use */
-	SDL_windowid = SDL_getenv("SDL_WINDOWID");
+    /* Save DPMS and screensaver settings */
+    X11_SaveScreenSaver (SDL_Display, &screensaver_timeout, &dpms_enabled);
+    X11_DisableScreenSaver (SDL_Display);
 
-	/* Create the fullscreen and managed windows */
-	create_aux_windows(this);
+    /* See if we have been passed a window to use */
+    SDL_windowid = SDL_getenv ("SDL_WINDOWID");
 
-	/* Create the blank cursor */
-	SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
-					BLANK_CWIDTH, BLANK_CHEIGHT,
-						BLANK_CHOTX, BLANK_CHOTY);
+    /* Create the fullscreen and managed windows */
+    create_aux_windows (this);
 
-	/* Fill in some window manager capabilities */
-	this->info.wm_available = 1;
+    /* Create the blank cursor */
+    SDL_BlankCursor = this->CreateWMCursor (this, blank_cdata, blank_cmask,
+                                            BLANK_CWIDTH, BLANK_CHEIGHT,
+                                            BLANK_CHOTX, BLANK_CHOTY);
 
-	/* We're done! */
-	XFlush(SDL_Display);
-	return(0);
+    /* 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)
+static void
+X11_DestroyWindow (_THIS, SDL_Surface * screen)
 {
-	/* Clean up OpenGL */
-	if ( screen ) {
-		screen->flags &= ~SDL_INTERNALOPENGL;
-	}
-	X11_GL_Shutdown(this);
+    /* Clean up OpenGL */
+    if (screen) {
+        screen->flags &= ~SDL_INTERNALOPENGL;
+    }
+    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);
-		}
+    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);
+        }
 
-		/* 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;
-		} 
+        /* Destroy the output window */
+        if (SDL_Window) {
+            XDestroyWindow (SDL_Display, SDL_Window);
+        }
 
-		/* Free the graphics context */
-		if ( SDL_GC ) {
-			XFreeGC(SDL_Display, SDL_GC);
-			SDL_GC = 0;
-		}
-	}
+        /* 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)
+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;
+    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)
+static void
+X11_SetSizeHints (_THIS, int w, int h, Uint32 flags)
 {
-	XSizeHints *hints;
+    XSizeHints *hints;
 
-	hints = XAllocSizeHints();
-	if ( hints ) {
-		if ( flags & SDL_RESIZABLE ) {
-			hints->min_width = 32;
-			hints->min_height = 32;
-			hints->max_height = 4096;
-			hints->max_width = 4096;
-		} else {
-			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;
-			XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y);
+    hints = XAllocSizeHints ();
+    if (hints) {
+        if (flags & SDL_RESIZABLE) {
+            hints->min_width = 32;
+            hints->min_height = 32;
+            hints->max_height = 4096;
+            hints->max_width = 4096;
+        } else {
+            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;
+            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);
-	}
+            /* 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;
+    /* 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;
+        /* 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 };
+        /* 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 *) &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 *) &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;
+            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;
+        /* 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 ) {
-			/* NOTE: Does this work? */
-			XSetTransientForHint(SDL_Display, WMwindow, None);
-		}
-	}
+        /* 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) {
+            /* NOTE: Does this work? */
+            XSetTransientForHint (SDL_Display, WMwindow, None);
+        }
+    }
 }
 
-static int X11_CreateWindow(_THIS, SDL_Surface *screen,
-			    int w, int h, int bpp, Uint32 flags)
+static int
+X11_CreateWindow (_THIS, SDL_Surface * screen,
+                  const SDL_DisplayMode * mode, Uint32 flags)
 {
-	int i, depth;
-	Visual *vis;
-	int vis_change;
-	Uint32 Amask;
+    int i, depth;
+    Visual *vis;
+    int vis_change;
+    int bpp;
+    Uint32 Rmask, Gmask, Bmask, 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. */
-	}
+    SDL_PixelFormatEnumToMasks (mode->format, &bpp, &Rmask, &Gmask, &Bmask,
+                                &Amask);
 
-	/* 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_INTERNALOPENGL ) {
-		XVisualInfo *vi;
+    /* 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. */
+    }
 
-		vi = X11_GL_GetVisual(this);
-		if( !vi ) {
-			return -1;
-		}
-		vis = vi->visual;
-		depth = vi->depth;
-	} else if ( SDL_windowid ) {
-		XWindowAttributes a;
+    /* See if we have been given a window id */
+    if (SDL_windowid) {
+        SDL_Window = SDL_strtol (SDL_windowid, NULL, 0);
+    } else {
+        SDL_Window = 0;
+    }
 
-		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;
+    /* find out which visual we are going to use */
+    if (flags & SDL_INTERNALOPENGL) {
+        XVisualInfo *vi;
+
+        vi = X11_GL_GetVisual (this);
+        if (!vi) {
+            return -1;
+        }
+        vis = vi->visual;
+        depth = vi->depth;
+    } else if (SDL_windowid) {
+        XWindowAttributes a;
 
-	/* 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;
-	}
+        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 &&
+                this->hidden->visuals[i].visual->red_mask == Rmask &&
+                this->hidden->visuals[i].visual->green_mask == Gmask &&
+                this->hidden->visuals[i].visual->blue_mask == Bmask)
+                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;
 
-	/* 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));
+    /* Allocate the new pixel format for this video mode */
+    if (!SDL_ReallocFormat (screen, bpp, Rmask, Gmask, Bmask, Amask)) {
+        return -1;
+    }
 
-	    /* 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 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));
 
-	    /* Create a colormap which we can manipulate for gamma */
-	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
-		                            SDL_Visual, AllocAll);
-            XSync(SDL_Display, False);
+        /* 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) {
 
-	    /* 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);
-	}
+        /* Create a colormap which we can manipulate for gamma */
+        SDL_XColorMap = XCreateColormap (SDL_Display, SDL_Root,
+                                         SDL_Visual, AllocAll);
+        XSync (SDL_Display, False);
 
-	/* Recreate the auxiliary windows, if needed (required for GL) */
-	if ( vis_change )
-	    create_aux_windows(this);
+        /* Initialize the colormap to the identity mapping */
+        SDL_GetGammaRamp (0, 0, 0);
+        SDL_VideoSurface = screen;
+        X11_SetGammaRamp (this, SDL_CurrentWindow.gamma);
+        SDL_VideoSurface = NULL;
+    } else {
+        /* Create a read-only colormap for our window */
+        SDL_XColorMap = XCreateColormap (SDL_Display, SDL_Root,
+                                         SDL_Visual, AllocNone);
+    }
 
-	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);
-	}
+    /* 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);
-	}
+    /* resize the (possibly new) window manager window */
+    if (!SDL_windowid) {
+        X11_SetSizeHints (this, mode->w, mode->h, flags);
+        window_w = mode->w;
+        window_h = mode->h;
+        XResizeWindow (SDL_Display, WMwindow, mode->w, mode->h);
+    }
 
-	/* Create (or use) the X11 display window */
-	if ( !SDL_windowid ) {
-		if ( flags & SDL_INTERNALOPENGL ) {
-			if ( X11_GL_CreateWindow(this, w, h) < 0 ) {
-				return(-1);
-			}
-		} else {
-			XSetWindowAttributes swa;
+    /* Create (or use) the X11 display window */
+    if (!SDL_windowid) {
+        if (flags & SDL_INTERNALOPENGL) {
+            if (X11_GL_CreateWindow (this, mode->w, mode->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_INTERNALOPENGL ) {
-		if ( X11_GL_CreateContext(this) < 0 ) {
-			return(-1);
-		} else {
-			screen->flags |= SDL_INTERNALOPENGL;
-		}
-	} else {
-		XGCValues gcv;
+            swa.background_pixel = 0;
+            swa.border_pixel = 0;
+            swa.colormap = SDL_XColorMap;
+            SDL_Window = XCreateWindow (SDL_Display, WMwindow,
+                                        0, 0, mode->w, mode->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_INTERNALOPENGL) {
+        if (X11_GL_CreateContext (this) < 0) {
+            return (-1);
+        } else {
+            screen->flags |= SDL_INTERNALOPENGL;
+        }
+    } 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);
-		}
-	}
+        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_INTERNALOPENGL) ) {
-		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") )
+    /* Set our colormaps when not setting a GL mode */
+    if (!(flags & SDL_INTERNALOPENGL)) {
+        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;
+        /* 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);
-		}
-	}
+        xscreen = ScreenOfDisplay (SDL_Display, SDL_Screen);
+        a.backing_store = DoesBackingStore (xscreen);
+        if (a.backing_store != NotUseful) {
+            XChangeWindowAttributes (SDL_Display, SDL_Window,
+                                     CWBackingStore, &a);
+        }
+    }
 
-	/* Update the internal keyboard state */
-	X11_SetKeyboardState(SDL_Display, NULL);
+    /* Update the internal keyboard state */
+    X11_SetKeyboardState (SDL_Display, NULL);
 
-	/* When the window is first mapped, ignore non-modifier keys */
-	{
-		Uint8 *keys = SDL_GetKeyState(NULL);
-		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;
-			}
-		}
-	}
+    /* When the window is first mapped, ignore non-modifier keys */
+    {
+        Uint8 *keys = SDL_GetKeyState (NULL);
+        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;
+            }
+        }
+    }
 
-	/* 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);
+    /* 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)
+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);
+    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);
+        /* 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)
+SDL_Surface *
+X11_SetVideoMode (_THIS, SDL_Surface * current,
+                  const SDL_DisplayMode * mode, Uint32 flags)
 {
-	Uint32 saved_flags;
+    Uint32 saved_flags;
 
-	/* Lock the event thread, in multi-threading environments */
-	SDL_Lock_EventThread();
+    /* 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;
-		}
-	}
+    /* 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);
+    /* Flush any delayed updates */
+    XSync (GFX_Display, False);
 
-	/* Set up the X11 window */
-	saved_flags = current->flags;
-	if ( (SDL_Window) && ((saved_flags&SDL_INTERNALOPENGL) == (flags&SDL_INTERNALOPENGL))
-	      && (bpp == current->format->BitsPerPixel)
-          && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) {
-		if (X11_ResizeWindow(this, current, width, height, flags) < 0) {
-			current = NULL;
-			goto done;
-		}
-	} else {
-		if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) {
-			current = NULL;
-			goto done;
-		}
-	}
+    /* Set up the X11 window */
+    saved_flags = current->flags;
+    if ((SDL_Window)
+        && ((saved_flags & SDL_INTERNALOPENGL) ==
+            (flags & SDL_INTERNALOPENGL))
+        && (mode->format == SDL_CurrentDisplay.current_mode.format)
+        && ((saved_flags & SDL_NOFRAME) == (flags & SDL_NOFRAME))) {
+        if (X11_ResizeWindow (this, current, mode->w, mode->h, flags) < 0) {
+            current = NULL;
+            goto done;
+        }
+    } else {
+        if (X11_CreateWindow (this, current, mode, flags) < 0) {
+            current = NULL;
+            goto done;
+        }
+    }
 
-	/* Set up the new mode framebuffer */
-	if ( ((current->w != width) || (current->h != height)) ||
-             ((saved_flags&SDL_INTERNALOPENGL) != (flags&SDL_INTERNALOPENGL)) ) {
-		current->w = width;
-		current->h = height;
-		current->pitch = SDL_CalculatePitch(current);
-		X11_ResizeImage(this, current, flags);
-	}
-	current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME));
+    /* Set up the new mode framebuffer */
+    if (((current->w != mode->w) || (current->h != mode->h)) ||
+        ((saved_flags & SDL_INTERNALOPENGL) != (flags & SDL_INTERNALOPENGL)))
+    {
+        current->w = mode->w;
+        current->h = mode->h;
+        current->pitch = SDL_CalculatePitch (current);
+        X11_ResizeImage (this, current, flags);
+    }
+    current->flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME));
 
   done:
-	/* Release the event thread */
-	XSync(SDL_Display, False);
-	SDL_Unlock_EventThread();
+    /* Release the event thread */
+    XSync (SDL_Display, False);
+    SDL_Unlock_EventThread ();
 
-	/* We're done! */
-	return(current);
+    /* We're done! */
+    return (current);
 }
 
-static int X11_ToggleFullScreen(_THIS, int on)
+static int
+X11_ToggleFullScreen (_THIS, int on)
 {
-	Uint32 event_thread;
+    Uint32 event_thread;
 
-	/* Don't switch if we don't own the window */
-	if ( SDL_windowid ) {
-		return(0);
-	}
+    /* 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);
+    /* 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) {
+        SDL_VideoSurface->flags |= SDL_FULLSCREEN;
+        X11_EnterFullScreen (this);
+    } else {
+        SDL_VideoSurface->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)
+static void
+X11_UpdateMouse (_THIS)
 {
-	Window u1; int u2;
-	Window current_win;
-	int x, y;
-	unsigned int mask;
+    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();
+    /* 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
@@ -1145,268 +1185,275 @@
 	(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)
+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);
+    /*
+     * 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--;
-		}
-	}
+    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
+X11_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	int nrej = 0;
+    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);
+    /* Check to make sure we have a colormap allocated */
+    if (SDL_XPixels == NULL) {
+        return (0);
+    }
+    if ((SDL_VideoSurface->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 = SDL_VideoSurface->format->palette->ncolors;
+        colors = SDL_VideoSurface->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));
+        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;
+        /* 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
+X11_SetGammaRamp (_THIS, Uint16 * ramp)
 {
-	int i, ncolors;
-	XColor xcmap[256];
+    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);
-	}
+    /* 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);
+    /* 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 (SDL_VideoSurface->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)
+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);
+    /* 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) {
-			XDestroyIC(SDL_IC);
-			SDL_IC = NULL;
-		}
-		if (SDL_IM != NULL) {
-			XCloseIM(SDL_IM);
-			SDL_IM = NULL;
-		}
-		#endif
+        /* Close the connection with the IM server */
+#ifdef X_HAVE_UTF8_STRING
+        if (SDL_IC != NULL) {
+            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;
-		} 
+        /* Start shutting down the windows */
+        X11_DestroyImage (this, SDL_VideoSurface);
+        X11_DestroyWindow (this, SDL_VideoSurface);
+        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;
+        }
+        if (xinerama) {
+            XFree (xinerama);
+        }
 
-		/* Restore gamma settings if they've changed */
-		if ( SDL_GetAppState() & SDL_APPACTIVE ) {
-			X11_SwapVidModeGamma(this);
-		}
-
-		/* Restore DPMS and screensaver settings */
-		X11_RestoreScreenSaver(SDL_Display, screensaver_timeout, dpms_enabled);
+        /* 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;
-		}
+        /* Restore DPMS and screensaver settings */
+        X11_RestoreScreenSaver (SDL_Display, screensaver_timeout,
+                                dpms_enabled);
 
-		/* Close the X11 graphics connection */
-		if ( GFX_Display != NULL ) {
-			XCloseDisplay(GFX_Display);
-			GFX_Display = NULL;
-		}
+        /* Free that blank cursor */
+        if (SDL_BlankCursor != NULL) {
+            this->FreeWMCursor (this, SDL_BlankCursor);
+            SDL_BlankCursor = NULL;
+        }
 
-		/* Close the X11 display connection */
-		XCloseDisplay(SDL_Display);
-		SDL_Display = NULL;
+        /* Close the X11 graphics connection */
+        if (GFX_Display != NULL) {
+            XCloseDisplay (GFX_Display);
+            GFX_Display = NULL;
+        }
 
-		/* Reset the X11 error handlers */
-		if ( XIO_handler ) {
-			XSetIOErrorHandler(XIO_handler);
-		}
-		if ( X_handler ) {
-			XSetErrorHandler(X_handler);
-		}
+        /* Close the X11 display connection */
+        XCloseDisplay (SDL_Display);
+        SDL_Display = NULL;
 
-		/* 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;
-	}
+        /* 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 (SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_HWSURFACE)) {
+        /* Direct screen access, no memory buffer */
+        SDL_VideoSurface->pixels = NULL;
+    }
 }
 
+/* vi: set ts=4 sw=4 expandtab: */