src/video/x11/SDL_x11video.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* 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"

/* Initialization/Query functions */
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)
{
    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));

        /* Set the driver flags */
        device->handles_any_size = 1;

        /* 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;
#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 (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;
    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_VIDMODE
    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.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, SDL_CurrentWindow.wm_title,
                         SDL_CurrentWindow.wm_icon);

    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));
    {
        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;

#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

    /* Allow the window to be deleted by the window manager */
    XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
}

static int
X11_VideoInit(_THIS)
{
    char *display;
    int i;
    SDL_DisplayMode desktop_mode;

    /* 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) {
        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 visuals */
    if (X11_GetVisuals(this) < 0)
        return -1;

    /* 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);

    /* Get the available video modes */
    if (X11_GetVideoModes(this) < 0)
        return -1;

    X11_SaveVidModeGamma(this);

    /* Save DPMS and screensaver settings */
    X11_SaveScreenSaver(SDL_Display, &screensaver_timeout, &dpms_enabled);
    X11_DisableScreenSaver(SDL_Display);

    /* 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_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);
        }

        /* 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 = 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);
    }

    /* 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) {
            /* NOTE: Does this work? */
            XSetTransientForHint(SDL_Display, WMwindow, None);
        }
    }
}

static int
X11_CreateWindow(_THIS, SDL_Surface * screen,
                 const SDL_DisplayMode * mode, Uint32 flags)
{
    int i, depth;
    Visual *vis;
    int vis_change;
    int bpp;
    Uint32 Rmask, Gmask, Bmask, Amask;

    SDL_PixelFormatEnumToMasks(mode->format, &bpp, &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. */
    }

    /* 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;

        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 &&
                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;

    /* Allocate the new pixel format for this video mode */
    if (!SDL_ReallocFormat(screen, bpp, Rmask, Gmask, Bmask, 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);
        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);
    }

    /* 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, 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, 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, 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);
        }
    }

    /* 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;

        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);

    /* 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);
}

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,
                 const SDL_DisplayMode * mode, 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_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 != 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();

    /* 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) {
        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)
{
    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 ((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));

        /* 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(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)
{
    /* 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

        /* 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);

        /* 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 (SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_HWSURFACE)) {
        /* Direct screen access, no memory buffer */
        SDL_VideoSurface->pixels = NULL;
    }
}

/* vi: set ts=4 sw=4 expandtab: */