src/video/x11/SDL_x11video.c
author Ryan C. Gordon <icculus@icculus.org>
Fri, 06 Apr 2007 20:30:41 +0000
branchSDL-1.2
changeset 3936 c5c3c772f5aa
parent 3885 a10bddfdc40f
child 3964 3dc92ff218dd
permissions -rw-r--r--
Let app set SDL_VIDEO_ALLOW_SCREENSAVER environment variable to override SDL's
attempt to disable screen savers. Works for Quartz (Mac OS X) and X11.

Need a formal API for this in 1.3, still.

Fixes Bugzilla #415.
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2006 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 #include "SDL_config.h"
    23 
    24 /* X11 based SDL video driver implementation.
    25    Note:  This implementation does not currently need X11 thread locking,
    26           since the event thread uses a separate X connection and any
    27           additional locking necessary is handled internally.  However,
    28           if full locking is neccessary, take a look at XInitThreads().
    29 */
    30 
    31 #include <unistd.h>
    32 #include <sys/ioctl.h>
    33 #ifdef MTRR_SUPPORT
    34 #include <asm/mtrr.h>
    35 #include <sys/fcntl.h>
    36 #endif
    37 
    38 #include "SDL_endian.h"
    39 #include "SDL_timer.h"
    40 #include "SDL_thread.h"
    41 #include "SDL_video.h"
    42 #include "SDL_mouse.h"
    43 #include "../SDL_sysvideo.h"
    44 #include "../SDL_pixels_c.h"
    45 #include "../../events/SDL_events_c.h"
    46 #include "SDL_x11video.h"
    47 #include "SDL_x11wm_c.h"
    48 #include "SDL_x11mouse_c.h"
    49 #include "SDL_x11events_c.h"
    50 #include "SDL_x11modes_c.h"
    51 #include "SDL_x11image_c.h"
    52 #include "SDL_x11yuv_c.h"
    53 #include "SDL_x11gl_c.h"
    54 #include "SDL_x11gamma_c.h"
    55 #include "../blank_cursor.h"
    56 
    57 /* Initialization/Query functions */
    58 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat);
    59 static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
    60 static int X11_ToggleFullScreen(_THIS, int on);
    61 static void X11_UpdateMouse(_THIS);
    62 static int X11_SetColors(_THIS, int firstcolor, int ncolors,
    63 			 SDL_Color *colors);
    64 static int X11_SetGammaRamp(_THIS, Uint16 *ramp);
    65 static void X11_VideoQuit(_THIS);
    66 
    67 
    68 /* X11 driver bootstrap functions */
    69 
    70 static int X11_Available(void)
    71 {
    72 	Display *display = NULL;
    73 	if ( SDL_X11_LoadSymbols() ) {
    74 		display = XOpenDisplay(NULL);
    75 		if ( display != NULL ) {
    76 			XCloseDisplay(display);
    77 		}
    78 		SDL_X11_UnloadSymbols();
    79 	}
    80 	return(display != NULL);
    81 }
    82 
    83 static void X11_DeleteDevice(SDL_VideoDevice *device)
    84 {
    85 	if ( device ) {
    86 		if ( device->hidden ) {
    87 			SDL_free(device->hidden);
    88 		}
    89 		if ( device->gl_data ) {
    90 			SDL_free(device->gl_data);
    91 		}
    92 		SDL_free(device);
    93 		SDL_X11_UnloadSymbols();
    94 	}
    95 }
    96 
    97 static SDL_VideoDevice *X11_CreateDevice(int devindex)
    98 {
    99 	SDL_VideoDevice *device = NULL;
   100 
   101 	if ( SDL_X11_LoadSymbols() ) {
   102 		/* Initialize all variables that we clean on shutdown */
   103 		device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
   104 		if ( device ) {
   105 			SDL_memset(device, 0, (sizeof *device));
   106 			device->hidden = (struct SDL_PrivateVideoData *)
   107 					SDL_malloc((sizeof *device->hidden));
   108 			device->gl_data = (struct SDL_PrivateGLData *)
   109 					SDL_malloc((sizeof *device->gl_data));
   110 		}
   111 		if ( (device == NULL) || (device->hidden == NULL) ||
   112 		                         (device->gl_data == NULL) ) {
   113 			SDL_OutOfMemory();
   114 			X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */
   115 			return(0);
   116 		}
   117 		SDL_memset(device->hidden, 0, (sizeof *device->hidden));
   118 		SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
   119 
   120 		/* Set the driver flags */
   121 		device->handles_any_size = 1;
   122 
   123 		/* Set the function pointers */
   124 		device->VideoInit = X11_VideoInit;
   125 		device->ListModes = X11_ListModes;
   126 		device->SetVideoMode = X11_SetVideoMode;
   127 		device->ToggleFullScreen = X11_ToggleFullScreen;
   128 		device->UpdateMouse = X11_UpdateMouse;
   129 #if SDL_VIDEO_DRIVER_X11_XV
   130 		device->CreateYUVOverlay = X11_CreateYUVOverlay;
   131 #endif
   132 		device->SetColors = X11_SetColors;
   133 		device->UpdateRects = NULL;
   134 		device->VideoQuit = X11_VideoQuit;
   135 		device->AllocHWSurface = X11_AllocHWSurface;
   136 		device->CheckHWBlit = NULL;
   137 		device->FillHWRect = NULL;
   138 		device->SetHWColorKey = NULL;
   139 		device->SetHWAlpha = NULL;
   140 		device->LockHWSurface = X11_LockHWSurface;
   141 		device->UnlockHWSurface = X11_UnlockHWSurface;
   142 		device->FlipHWSurface = X11_FlipHWSurface;
   143 		device->FreeHWSurface = X11_FreeHWSurface;
   144 		device->SetGamma = X11_SetVidModeGamma;
   145 		device->GetGamma = X11_GetVidModeGamma;
   146 		device->SetGammaRamp = X11_SetGammaRamp;
   147 		device->GetGammaRamp = NULL;
   148 #if SDL_VIDEO_OPENGL_GLX
   149 		device->GL_LoadLibrary = X11_GL_LoadLibrary;
   150 		device->GL_GetProcAddress = X11_GL_GetProcAddress;
   151 		device->GL_GetAttribute = X11_GL_GetAttribute;
   152 		device->GL_MakeCurrent = X11_GL_MakeCurrent;
   153 		device->GL_SwapBuffers = X11_GL_SwapBuffers;
   154 #endif
   155 		device->SetCaption = X11_SetCaption;
   156 		device->SetIcon = X11_SetIcon;
   157 		device->IconifyWindow = X11_IconifyWindow;
   158 		device->GrabInput = X11_GrabInput;
   159 		device->GetWMInfo = X11_GetWMInfo;
   160 		device->FreeWMCursor = X11_FreeWMCursor;
   161 		device->CreateWMCursor = X11_CreateWMCursor;
   162 		device->ShowWMCursor = X11_ShowWMCursor;
   163 		device->WarpWMCursor = X11_WarpWMCursor;
   164 		device->CheckMouseMode = X11_CheckMouseMode;
   165 		device->InitOSKeymap = X11_InitOSKeymap;
   166 		device->PumpEvents = X11_PumpEvents;
   167 
   168 		device->free = X11_DeleteDevice;
   169 	}
   170 
   171 	return device;
   172 }
   173 
   174 VideoBootStrap X11_bootstrap = {
   175 	"x11", "X Window System",
   176 	X11_Available, X11_CreateDevice
   177 };
   178 
   179 /* Normal X11 error handler routine */
   180 static int (*X_handler)(Display *, XErrorEvent *) = NULL;
   181 static int x_errhandler(Display *d, XErrorEvent *e)
   182 {
   183 #if SDL_VIDEO_DRIVER_X11_VIDMODE
   184 	extern int vm_error;
   185 #endif
   186 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE
   187 	extern int dga_error;
   188 #endif
   189 
   190 #if SDL_VIDEO_DRIVER_X11_VIDMODE
   191 	/* VidMode errors are non-fatal. :) */
   192 	/* Are the errors offset by one from the error base?
   193 	   e.g. the error base is 143, the code is 148, and the
   194 	        actual error is XF86VidModeExtensionDisabled (4) ?
   195 	 */
   196         if ( (vm_error >= 0) &&
   197 	     (((e->error_code == BadRequest)&&(e->request_code == vm_error)) ||
   198 	      ((e->error_code > vm_error) &&
   199 	       (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) {
   200 #ifdef X11_DEBUG
   201 { char errmsg[1024];
   202   XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
   203 printf("VidMode error: %s\n", errmsg);
   204 }
   205 #endif
   206         	return(0);
   207         }
   208 #endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
   209 
   210 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE
   211 	/* DGA errors can be non-fatal. :) */
   212         if ( (dga_error >= 0) &&
   213 	     ((e->error_code > dga_error) &&
   214 	      (e->error_code <= (dga_error+XF86DGANumberErrors))) ) {
   215 #ifdef X11_DEBUG
   216 { char errmsg[1024];
   217   XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
   218 printf("DGA error: %s\n", errmsg);
   219 }
   220 #endif
   221         	return(0);
   222         }
   223 #endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */
   224 
   225 	return(X_handler(d,e));
   226 }
   227 
   228 /* X11 I/O error handler routine */
   229 static int (*XIO_handler)(Display *) = NULL;
   230 static int xio_errhandler(Display *d)
   231 {
   232 	/* Ack!  Lost X11 connection! */
   233 
   234 	/* We will crash if we try to clean up our display */
   235 	if ( current_video->hidden->Ximage ) {
   236 		SDL_VideoSurface->pixels = NULL;
   237 	}
   238 	current_video->hidden->X11_Display = NULL;
   239 
   240 	/* Continue with the standard X11 error handler */
   241 	return(XIO_handler(d));
   242 }
   243 
   244 static int (*Xext_handler)(Display *, _Xconst char *, _Xconst char *) = NULL;
   245 static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason)
   246 {
   247 #ifdef X11_DEBUG
   248 	printf("Xext error inside SDL (may be harmless):\n");
   249 	printf("  Extension \"%s\" %s on display \"%s\".\n",
   250 	       ext, reason, XDisplayString(d));
   251 #endif
   252 
   253 	if (SDL_strcmp(reason, "missing") == 0) {
   254 		/*
   255 		 * Since the query itself, elsewhere, can handle a missing extension
   256 		 *  and the default behaviour in Xlib is to write to stderr, which
   257 		 *  generates unnecessary bug reports, we just ignore these.
   258 		 */
   259 		return 0;
   260 	}
   261 
   262 	/* Everything else goes to the default handler... */
   263 	return Xext_handler(d, ext, reason);
   264 }
   265 
   266 /* Find out what class name we should use */
   267 static char *get_classname(char *classname, int maxlen)
   268 {
   269 	char *spot;
   270 #if defined(__LINUX__) || defined(__FREEBSD__)
   271 	char procfile[1024];
   272 	char linkfile[1024];
   273 	int linksize;
   274 #endif
   275 
   276 	/* First allow environment variable override */
   277 	spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS");
   278 	if ( spot ) {
   279 		SDL_strlcpy(classname, spot, maxlen);
   280 		return classname;
   281 	}
   282 
   283 	/* Next look at the application's executable name */
   284 #if defined(__LINUX__) || defined(__FREEBSD__)
   285 #if defined(__LINUX__)
   286 	SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid());
   287 #elif defined(__FREEBSD__)
   288 	SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file", getpid());
   289 #else
   290 #error Where can we find the executable name?
   291 #endif
   292 	linksize = readlink(procfile, linkfile, sizeof(linkfile)-1);
   293 	if ( linksize > 0 ) {
   294 		linkfile[linksize] = '\0';
   295 		spot = SDL_strrchr(linkfile, '/');
   296 		if ( spot ) {
   297 			SDL_strlcpy(classname, spot+1, maxlen);
   298 		} else {
   299 			SDL_strlcpy(classname, linkfile, maxlen);
   300 		}
   301 		return classname;
   302 	}
   303 #endif /* __LINUX__ */
   304 
   305 	/* Finally use the default we've used forever */
   306 	SDL_strlcpy(classname, "SDL_App", maxlen);
   307 	return classname;
   308 }
   309 
   310 /* Create auxiliary (toplevel) windows with the current visual */
   311 static void create_aux_windows(_THIS)
   312 {
   313     int x = 0, y = 0;
   314     char classname[1024];
   315     XSetWindowAttributes xattr;
   316     XWMHints *hints;
   317     int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
   318 
   319     /* Look up some useful Atoms */
   320     WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);
   321 
   322     /* Don't create any extra windows if we are being managed */
   323     if ( SDL_windowid ) {
   324 	FSwindow = 0;
   325 	WMwindow = SDL_strtol(SDL_windowid, NULL, 0);
   326         return;
   327     }
   328 
   329     if(FSwindow)
   330 	XDestroyWindow(SDL_Display, FSwindow);
   331 
   332 #if SDL_VIDEO_DRIVER_X11_XINERAMA
   333     if ( use_xinerama ) {
   334         x = xinerama_info.x_org;
   335         y = xinerama_info.y_org;
   336     }
   337 #endif
   338     xattr.override_redirect = True;
   339     xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
   340     xattr.border_pixel = 0;
   341     xattr.colormap = SDL_XColorMap;
   342 
   343     FSwindow = XCreateWindow(SDL_Display, SDL_Root,
   344                              x, y, 32, 32, 0,
   345 			     this->hidden->depth, InputOutput, SDL_Visual,
   346 			     CWOverrideRedirect | CWBackPixel | CWBorderPixel
   347 			     | CWColormap,
   348 			     &xattr);
   349 
   350     XSelectInput(SDL_Display, FSwindow, StructureNotifyMask);
   351 
   352     /* Tell KDE to keep the fullscreen window on top */
   353     {
   354 	XEvent ev;
   355 	long mask;
   356 
   357 	SDL_memset(&ev, 0, sizeof(ev));
   358 	ev.xclient.type = ClientMessage;
   359 	ev.xclient.window = SDL_Root;
   360 	ev.xclient.message_type = XInternAtom(SDL_Display,
   361 					      "KWM_KEEP_ON_TOP", False);
   362 	ev.xclient.format = 32;
   363 	ev.xclient.data.l[0] = FSwindow;
   364 	ev.xclient.data.l[1] = CurrentTime;
   365 	mask = SubstructureRedirectMask;
   366 	XSendEvent(SDL_Display, SDL_Root, False, mask, &ev);
   367     }
   368 
   369     hints = NULL;
   370     if(WMwindow) {
   371 	/* All window attributes must survive the recreation */
   372 	hints = XGetWMHints(SDL_Display, WMwindow);
   373 	XDestroyWindow(SDL_Display, WMwindow);
   374     }
   375 
   376     /* Create the window for windowed management */
   377     /* (reusing the xattr structure above) */
   378     WMwindow = XCreateWindow(SDL_Display, SDL_Root,
   379                              x, y, 32, 32, 0,
   380 			     this->hidden->depth, InputOutput, SDL_Visual,
   381 			     CWBackPixel | CWBorderPixel | CWColormap,
   382 			     &xattr);
   383 
   384     /* Set the input hints so we get keyboard input */
   385     if(!hints) {
   386 	hints = XAllocWMHints();
   387 	hints->input = True;
   388 	hints->flags = InputHint;
   389     }
   390     XSetWMHints(SDL_Display, WMwindow, hints);
   391     XFree(hints);
   392     X11_SetCaptionNoLock(this, this->wm_title, this->wm_icon);
   393 
   394     XSelectInput(SDL_Display, WMwindow,
   395 		 FocusChangeMask | KeyPressMask | KeyReleaseMask
   396 		 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask);
   397 
   398     /* Set the class hints so we can get an icon (AfterStep) */
   399     get_classname(classname, sizeof(classname));
   400     {
   401 	XClassHint *classhints;
   402 	classhints = XAllocClassHint();
   403 	if(classhints != NULL) {
   404 	    classhints->res_name = classname;
   405 	    classhints->res_class = classname;
   406 	    XSetClassHint(SDL_Display, WMwindow, classhints);
   407 	    XFree(classhints);
   408 	}
   409     }
   410 
   411     /* Setup the communication with the IM server */
   412 	SDL_IM = NULL;
   413 	SDL_IC = NULL;
   414 
   415 	#ifdef X_HAVE_UTF8_STRING
   416 	if (SDL_X11_HAVE_UTF8) {
   417 		SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname);
   418 		if (SDL_IM == NULL) {
   419 			SDL_SetError("no input method could be opened");
   420 		} else {
   421 			SDL_IC = pXCreateIC(SDL_IM,
   422 					XNClientWindow, WMwindow,
   423 					XNFocusWindow, WMwindow,
   424 					XNInputStyle, XIMPreeditNothing  | XIMStatusNothing,
   425 					XNResourceName, classname,
   426 					XNResourceClass, classname,
   427 					NULL);
   428 
   429 			if (SDL_IC == NULL) {
   430 				SDL_SetError("no input context could be created");
   431 				XCloseIM(SDL_IM);
   432 				SDL_IM = NULL;
   433 			}
   434 		}
   435 	}
   436 	#endif
   437 
   438 	/* Allow the window to be deleted by the window manager */
   439 	XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
   440 }
   441 
   442 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat)
   443 {
   444 	const char *env = NULL;
   445 	char *display;
   446 	int i;
   447 
   448 	/* Open the X11 display */
   449 	display = NULL;		/* Get it from DISPLAY environment variable */
   450 
   451 	if ( (SDL_strncmp(XDisplayName(display), ":", 1) == 0) ||
   452 	     (SDL_strncmp(XDisplayName(display), "unix:", 5) == 0) ) {
   453 		local_X11 = 1;
   454 	} else {
   455 		local_X11 = 0;
   456 	}
   457 	SDL_Display = XOpenDisplay(display);
   458 #if defined(__osf__) && defined(SDL_VIDEO_DRIVER_X11_DYNAMIC)
   459 	/* On Tru64 if linking without -lX11, it fails and you get following message.
   460 	 * Xlib: connection to ":0.0" refused by server
   461 	 * Xlib: XDM authorization key matches an existing client!
   462 	 *
   463 	 * It succeeds if retrying 1 second later
   464 	 * or if running xhost +localhost on shell.
   465 	 *
   466 	 */
   467 	if ( SDL_Display == NULL ) {
   468 		SDL_Delay(1000);
   469 		SDL_Display = XOpenDisplay(display);
   470 	}
   471 #endif
   472 	if ( SDL_Display == NULL ) {
   473 		SDL_SetError("Couldn't open X11 display");
   474 		return(-1);
   475 	}
   476 #ifdef X11_DEBUG
   477 	XSynchronize(SDL_Display, True);
   478 #endif
   479 
   480 	/* Create an alternate X display for graphics updates -- allows us
   481 	   to do graphics updates in a separate thread from event handling.
   482 	   Thread-safe X11 doesn't seem to exist.
   483 	 */
   484 	GFX_Display = XOpenDisplay(display);
   485 	if ( GFX_Display == NULL ) {
   486 		SDL_SetError("Couldn't open X11 display");
   487 		return(-1);
   488 	}
   489 
   490 	/* Set the normal X error handler */
   491 	X_handler = XSetErrorHandler(x_errhandler);
   492 
   493 	/* Set the error handler if we lose the X display */
   494 	XIO_handler = XSetIOErrorHandler(xio_errhandler);
   495 
   496 	/* Set the X extension error handler */
   497 	Xext_handler = XSetExtensionErrorHandler(xext_errhandler);
   498 
   499 	/* use default screen (from $DISPLAY) */
   500 	SDL_Screen = DefaultScreen(SDL_Display);
   501 
   502 #ifndef NO_SHARED_MEMORY
   503 	/* Check for MIT shared memory extension */
   504 	use_mitshm = 0;
   505 	if ( local_X11 ) {
   506 		use_mitshm = XShmQueryExtension(SDL_Display);
   507 	}
   508 #endif /* NO_SHARED_MEMORY */
   509 
   510 	/* Get the available video modes */
   511 	if(X11_GetVideoModes(this) < 0)
   512 	    return -1;
   513 
   514 	/* Determine the current screen size */
   515 	this->info.current_w = DisplayWidth(SDL_Display, SDL_Screen);
   516 	this->info.current_h = DisplayHeight(SDL_Display, SDL_Screen);
   517 
   518 	/* Determine the default screen depth:
   519 	   Use the default visual (or at least one with the same depth) */
   520 	SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen);
   521 	for(i = 0; i < this->hidden->nvisuals; i++)
   522 	    if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display,
   523 							      SDL_Screen))
   524 		break;
   525 	if(i == this->hidden->nvisuals) {
   526 	    /* default visual was useless, take the deepest one instead */
   527 	    i = 0;
   528 	}
   529 	SDL_Visual = this->hidden->visuals[i].visual;
   530 	if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) {
   531 	    SDL_XColorMap = SDL_DisplayColormap;
   532 	} else {
   533 	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
   534 					    SDL_Visual, AllocNone);
   535 	}
   536 	this->hidden->depth = this->hidden->visuals[i].depth;
   537 	vformat->BitsPerPixel = this->hidden->visuals[i].bpp;
   538 	if ( vformat->BitsPerPixel > 8 ) {
   539 		vformat->Rmask = SDL_Visual->red_mask;
   540 	  	vformat->Gmask = SDL_Visual->green_mask;
   541 	  	vformat->Bmask = SDL_Visual->blue_mask;
   542 	}
   543 	if ( this->hidden->depth == 32 ) {
   544 		vformat->Amask = (0xFFFFFFFF & ~(vformat->Rmask|vformat->Gmask|vformat->Bmask));
   545 	}
   546 	X11_SaveVidModeGamma(this);
   547 
   548 	/* Save DPMS and screensaver settings */
   549 	X11_SaveScreenSaver(SDL_Display, &screensaver_timeout, &dpms_enabled);
   550 	X11_DisableScreenSaver(this, SDL_Display);
   551 
   552 	/* See if we have been passed a window to use */
   553 	SDL_windowid = SDL_getenv("SDL_WINDOWID");
   554 
   555 	/* Create the fullscreen and managed windows */
   556 	create_aux_windows(this);
   557 
   558 	/* Create the blank cursor */
   559 	SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
   560 					BLANK_CWIDTH, BLANK_CHEIGHT,
   561 						BLANK_CHOTX, BLANK_CHOTY);
   562 
   563 	/* Fill in some window manager capabilities */
   564 	this->info.wm_available = 1;
   565 
   566 	/* Allow environment override of screensaver disable. */
   567 	env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
   568 	this->hidden->allow_screensaver = ( (env && SDL_atoi(env)) ? 1 : 0 );
   569 
   570 	/* We're done! */
   571 	XFlush(SDL_Display);
   572 	return(0);
   573 }
   574 
   575 static void X11_DestroyWindow(_THIS, SDL_Surface *screen)
   576 {
   577 	/* Clean up OpenGL */
   578 	if ( screen ) {
   579 		screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
   580 	}
   581 	X11_GL_Shutdown(this);
   582 
   583 	if ( ! SDL_windowid ) {
   584 		/* Hide the managed window */
   585 		if ( WMwindow ) {
   586 			XUnmapWindow(SDL_Display, WMwindow);
   587 		}
   588 		if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
   589 			screen->flags &= ~SDL_FULLSCREEN;
   590 			X11_LeaveFullScreen(this);
   591 		}
   592 
   593 		/* Destroy the output window */
   594 		if ( SDL_Window ) {
   595 			XDestroyWindow(SDL_Display, SDL_Window);
   596 		}
   597 
   598 		/* Free the colormap entries */
   599 		if ( SDL_XPixels ) {
   600 			int numcolors;
   601 			unsigned long pixel;
   602 			numcolors = SDL_Visual->map_entries;
   603 			for ( pixel=0; pixel<numcolors; ++pixel ) {
   604 				while ( SDL_XPixels[pixel] > 0 ) {
   605 					XFreeColors(GFX_Display,
   606 						SDL_DisplayColormap,&pixel,1,0);
   607 					--SDL_XPixels[pixel];
   608 				}
   609 			}
   610 			SDL_free(SDL_XPixels);
   611 			SDL_XPixels = NULL;
   612 		} 
   613 
   614 		/* Free the graphics context */
   615 		if ( SDL_GC ) {
   616 			XFreeGC(SDL_Display, SDL_GC);
   617 			SDL_GC = 0;
   618 		}
   619 	}
   620 }
   621 
   622 static SDL_bool X11_WindowPosition(_THIS, int *x, int *y, int w, int h)
   623 {
   624 	const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
   625 	const char *center = SDL_getenv("SDL_VIDEO_CENTERED");
   626 	if ( window ) {
   627 		if ( SDL_sscanf(window, "%d,%d", x, y) == 2 ) {
   628 			return SDL_TRUE;
   629 		}
   630 		if ( SDL_strcmp(window, "center") == 0 ) {
   631 			center = window;
   632 		}
   633 	}
   634 	if ( center ) {
   635 		*x = (DisplayWidth(SDL_Display, SDL_Screen) - w)/2;
   636 		*y = (DisplayHeight(SDL_Display, SDL_Screen) - h)/2;
   637 		return SDL_TRUE;
   638 	}
   639 	return SDL_FALSE;
   640 }
   641 
   642 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags)
   643 {
   644 	XSizeHints *hints;
   645 
   646 	hints = XAllocSizeHints();
   647 	if ( hints ) {
   648 		if ( flags & SDL_RESIZABLE ) {
   649 			hints->min_width = 32;
   650 			hints->min_height = 32;
   651 			hints->max_height = 4096;
   652 			hints->max_width = 4096;
   653 		} else {
   654 			hints->min_width = hints->max_width = w;
   655 			hints->min_height = hints->max_height = h;
   656 		}
   657 		hints->flags = PMaxSize | PMinSize;
   658 		if ( flags & SDL_FULLSCREEN ) {
   659 			hints->x = 0;
   660 			hints->y = 0;
   661 			hints->flags |= USPosition;
   662 		} else
   663 		/* Center it, if desired */
   664 		if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) {
   665 			hints->flags |= USPosition;
   666 			XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y);
   667 
   668 			/* Flush the resize event so we don't catch it later */
   669 			XSync(SDL_Display, True);
   670 		}
   671 		XSetWMNormalHints(SDL_Display, WMwindow, hints);
   672 		XFree(hints);
   673 	}
   674 
   675 	/* Respect the window caption style */
   676 	if ( flags & SDL_NOFRAME ) {
   677 		SDL_bool set;
   678 		Atom WM_HINTS;
   679 
   680 		/* We haven't modified the window manager hints yet */
   681 		set = SDL_FALSE;
   682 
   683 		/* First try to set MWM hints */
   684 		WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
   685 		if ( WM_HINTS != None ) {
   686 			/* Hints used by Motif compliant window managers */
   687 			struct {
   688 				unsigned long flags;
   689 				unsigned long functions;
   690 				unsigned long decorations;
   691 				long input_mode;
   692 				unsigned long status;
   693 			} MWMHints = { (1L << 1), 0, 0, 0, 0 };
   694 
   695 			XChangeProperty(SDL_Display, WMwindow,
   696 			                WM_HINTS, WM_HINTS, 32,
   697 			                PropModeReplace,
   698 					(unsigned char *)&MWMHints,
   699 					sizeof(MWMHints)/sizeof(long));
   700 			set = SDL_TRUE;
   701 		}
   702 		/* Now try to set KWM hints */
   703 		WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
   704 		if ( WM_HINTS != None ) {
   705 			long KWMHints = 0;
   706 
   707 			XChangeProperty(SDL_Display, WMwindow,
   708 			                WM_HINTS, WM_HINTS, 32,
   709 			                PropModeReplace,
   710 					(unsigned char *)&KWMHints,
   711 					sizeof(KWMHints)/sizeof(long));
   712 			set = SDL_TRUE;
   713 		}
   714 		/* Now try to set GNOME hints */
   715 		WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
   716 		if ( WM_HINTS != None ) {
   717 			long GNOMEHints = 0;
   718 
   719 			XChangeProperty(SDL_Display, WMwindow,
   720 			                WM_HINTS, WM_HINTS, 32,
   721 			                PropModeReplace,
   722 					(unsigned char *)&GNOMEHints,
   723 					sizeof(GNOMEHints)/sizeof(long));
   724 			set = SDL_TRUE;
   725 		}
   726 		/* Finally set the transient hints if necessary */
   727 		if ( ! set ) {
   728 			XSetTransientForHint(SDL_Display, WMwindow, SDL_Root);
   729 		}
   730 	} else {
   731 		SDL_bool set;
   732 		Atom WM_HINTS;
   733 
   734 		/* We haven't modified the window manager hints yet */
   735 		set = SDL_FALSE;
   736 
   737 		/* First try to unset MWM hints */
   738 		WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
   739 		if ( WM_HINTS != None ) {
   740 			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
   741 			set = SDL_TRUE;
   742 		}
   743 		/* Now try to unset KWM hints */
   744 		WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
   745 		if ( WM_HINTS != None ) {
   746 			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
   747 			set = SDL_TRUE;
   748 		}
   749 		/* Now try to unset GNOME hints */
   750 		WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
   751 		if ( WM_HINTS != None ) {
   752 			XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
   753 			set = SDL_TRUE;
   754 		}
   755 		/* Finally unset the transient hints if necessary */
   756 		if ( ! set ) {
   757 			/* NOTE: Does this work? */
   758 			XSetTransientForHint(SDL_Display, WMwindow, None);
   759 		}
   760 	}
   761 }
   762 
   763 static int X11_CreateWindow(_THIS, SDL_Surface *screen,
   764 			    int w, int h, int bpp, Uint32 flags)
   765 {
   766 	int i, depth;
   767 	Visual *vis;
   768 	int vis_change;
   769 	Uint32 Amask;
   770 
   771 	/* If a window is already present, destroy it and start fresh */
   772 	if ( SDL_Window ) {
   773 		X11_DestroyWindow(this, screen);
   774 		switch_waiting = 0; /* Prevent jump back to now-meaningless state. */
   775 	}
   776 
   777 	/* See if we have been given a window id */
   778 	if ( SDL_windowid ) {
   779 		SDL_Window = SDL_strtol(SDL_windowid, NULL, 0);
   780 	} else {
   781 		SDL_Window = 0;
   782 	}
   783 
   784 	/* find out which visual we are going to use */
   785 	if ( flags & SDL_OPENGL ) {
   786 		XVisualInfo *vi;
   787 
   788 		vi = X11_GL_GetVisual(this);
   789 		if( !vi ) {
   790 			return -1;
   791 		}
   792 		vis = vi->visual;
   793 		depth = vi->depth;
   794 	} else if ( SDL_windowid ) {
   795 		XWindowAttributes a;
   796 
   797 		XGetWindowAttributes(SDL_Display, SDL_Window, &a);
   798 		vis = a.visual;
   799 		depth = a.depth;
   800 	} else {
   801 		for ( i = 0; i < this->hidden->nvisuals; i++ ) {
   802 			if ( this->hidden->visuals[i].bpp == bpp )
   803 				break;
   804 		}
   805 		if ( i == this->hidden->nvisuals ) {
   806 			SDL_SetError("No matching visual for requested depth");
   807 			return -1;	/* should never happen */
   808 		}
   809 		vis = this->hidden->visuals[i].visual;
   810 		depth = this->hidden->visuals[i].depth;
   811 	}
   812 #ifdef X11_DEBUG
   813         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);
   814 #endif
   815 	vis_change = (vis != SDL_Visual);
   816 	SDL_Visual = vis;
   817 	this->hidden->depth = depth;
   818 
   819 	/* Allocate the new pixel format for this video mode */
   820 	if ( this->hidden->depth == 32 ) {
   821 		Amask = (0xFFFFFFFF & ~(vis->red_mask|vis->green_mask|vis->blue_mask));
   822 	} else {
   823 		Amask = 0;
   824 	}
   825 	if ( ! SDL_ReallocFormat(screen, bpp,
   826 			vis->red_mask, vis->green_mask, vis->blue_mask, Amask) ) {
   827 		return -1;
   828 	}
   829 
   830 	/* Create the appropriate colormap */
   831 	if ( SDL_XColorMap != SDL_DisplayColormap ) {
   832 		XFreeColormap(SDL_Display, SDL_XColorMap);
   833 	}
   834 	if ( SDL_Visual->class == PseudoColor ) {
   835 	    int ncolors;
   836 
   837 	    /* Allocate the pixel flags */
   838 	    ncolors = SDL_Visual->map_entries;
   839 	    SDL_XPixels = SDL_malloc(ncolors * sizeof(int));
   840 	    if(SDL_XPixels == NULL) {
   841 		SDL_OutOfMemory();
   842 		return -1;
   843 	    }
   844 	    SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels));
   845 
   846 	    /* always allocate a private colormap on non-default visuals */
   847 	    if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) {
   848 		flags |= SDL_HWPALETTE;
   849 	    }
   850 	    if ( flags & SDL_HWPALETTE ) {
   851 		screen->flags |= SDL_HWPALETTE;
   852 		SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
   853 		                                SDL_Visual, AllocAll);
   854 	    } else {
   855 		SDL_XColorMap = SDL_DisplayColormap;
   856 	    }
   857 	} else if ( SDL_Visual->class == DirectColor ) {
   858 
   859 	    /* Create a colormap which we can manipulate for gamma */
   860 	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
   861 		                            SDL_Visual, AllocAll);
   862             XSync(SDL_Display, False);
   863 
   864 	    /* Initialize the colormap to the identity mapping */
   865 	    SDL_GetGammaRamp(0, 0, 0);
   866 	    this->screen = screen;
   867 	    X11_SetGammaRamp(this, this->gamma);
   868 	    this->screen = NULL;
   869 	} else {
   870 	    /* Create a read-only colormap for our window */
   871 	    SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
   872 	                                    SDL_Visual, AllocNone);
   873 	}
   874 
   875 	/* Recreate the auxiliary windows, if needed (required for GL) */
   876 	if ( vis_change )
   877 	    create_aux_windows(this);
   878 
   879 	if(screen->flags & SDL_HWPALETTE) {
   880 	    /* Since the full-screen window might have got a nonzero background
   881 	       colour (0 is white on some displays), we should reset the
   882 	       background to 0 here since that is what the user expects
   883 	       with a private colormap */
   884 	    XSetWindowBackground(SDL_Display, FSwindow, 0);
   885 	    XClearWindow(SDL_Display, FSwindow);
   886 	}
   887 
   888 	/* resize the (possibly new) window manager window */
   889 	if( !SDL_windowid ) {
   890 	        X11_SetSizeHints(this, w, h, flags);
   891 		window_w = w;
   892 		window_h = h;
   893 		XResizeWindow(SDL_Display, WMwindow, w, h);
   894 	}
   895 
   896 	/* Create (or use) the X11 display window */
   897 	if ( !SDL_windowid ) {
   898 		if ( flags & SDL_OPENGL ) {
   899 			if ( X11_GL_CreateWindow(this, w, h) < 0 ) {
   900 				return(-1);
   901 			}
   902 		} else {
   903 			XSetWindowAttributes swa;
   904 
   905 			swa.background_pixel = 0;
   906 			swa.border_pixel = 0;
   907 			swa.colormap = SDL_XColorMap;
   908 			SDL_Window = XCreateWindow(SDL_Display, WMwindow,
   909 		                           	0, 0, w, h, 0, depth,
   910 		                           	InputOutput, SDL_Visual,
   911 		                           	CWBackPixel | CWBorderPixel
   912 		                           	| CWColormap, &swa);
   913 		}
   914 		/* Only manage our input if we own the window */
   915 		XSelectInput(SDL_Display, SDL_Window,
   916 					( EnterWindowMask | LeaveWindowMask
   917 					| ButtonPressMask | ButtonReleaseMask
   918 					| PointerMotionMask | ExposureMask ));
   919 	}
   920 	/* Create the graphics context here, once we have a window */
   921 	if ( flags & SDL_OPENGL ) {
   922 		if ( X11_GL_CreateContext(this) < 0 ) {
   923 			return(-1);
   924 		} else {
   925 			screen->flags |= SDL_OPENGL;
   926 		}
   927 	} else {
   928 		XGCValues gcv;
   929 
   930 		gcv.graphics_exposures = False;
   931 		SDL_GC = XCreateGC(SDL_Display, SDL_Window,
   932 		                   GCGraphicsExposures, &gcv);
   933 		if ( ! SDL_GC ) {
   934 			SDL_SetError("Couldn't create graphics context");
   935 			return(-1);
   936 		}
   937 	}
   938 
   939 	/* Set our colormaps when not setting a GL mode */
   940 	if ( ! (flags & SDL_OPENGL) ) {
   941 		XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
   942 		if( !SDL_windowid ) {
   943 		    XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap);
   944 		    XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap);
   945 		}
   946 	}
   947 
   948 #if 0 /* This is an experiment - are the graphics faster now? - nope. */
   949 	if ( SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE") )
   950 #endif
   951 	/* Cache the window in the server, when possible */
   952 	{
   953 		Screen *xscreen;
   954 		XSetWindowAttributes a;
   955 
   956 		xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen);
   957 		a.backing_store = DoesBackingStore(xscreen);
   958 		if ( a.backing_store != NotUseful ) {
   959 			XChangeWindowAttributes(SDL_Display, SDL_Window,
   960 			                        CWBackingStore, &a);
   961 		}
   962 	}
   963 
   964 	/* Update the internal keyboard state */
   965 	X11_SetKeyboardState(SDL_Display, NULL);
   966 
   967 	/* When the window is first mapped, ignore non-modifier keys */
   968 	{
   969 		Uint8 *keys = SDL_GetKeyState(NULL);
   970 		for ( i = 0; i < SDLK_LAST; ++i ) {
   971 			switch (i) {
   972 			    case SDLK_NUMLOCK:
   973 			    case SDLK_CAPSLOCK:
   974 			    case SDLK_LCTRL:
   975 			    case SDLK_RCTRL:
   976 			    case SDLK_LSHIFT:
   977 			    case SDLK_RSHIFT:
   978 			    case SDLK_LALT:
   979 			    case SDLK_RALT:
   980 			    case SDLK_LMETA:
   981 			    case SDLK_RMETA:
   982 			    case SDLK_MODE:
   983 				break;
   984 			    default:
   985 				keys[i] = SDL_RELEASED;
   986 				break;
   987 			}
   988 		}
   989 	}
   990 
   991 	/* Map them both and go fullscreen, if requested */
   992 	if ( ! SDL_windowid ) {
   993 		XMapWindow(SDL_Display, SDL_Window);
   994 		XMapWindow(SDL_Display, WMwindow);
   995 		X11_WaitMapped(this, WMwindow);
   996 		if ( flags & SDL_FULLSCREEN ) {
   997 			screen->flags |= SDL_FULLSCREEN;
   998 			X11_EnterFullScreen(this);
   999 		} else {
  1000 			screen->flags &= ~SDL_FULLSCREEN;
  1001 		}
  1002 	}
  1003 	
  1004 	return(0);
  1005 }
  1006 
  1007 static int X11_ResizeWindow(_THIS,
  1008 			SDL_Surface *screen, int w, int h, Uint32 flags)
  1009 {
  1010 	if ( ! SDL_windowid ) {
  1011 		/* Resize the window manager window */
  1012 		X11_SetSizeHints(this, w, h, flags);
  1013 		window_w = w;
  1014 		window_h = h;
  1015 		XResizeWindow(SDL_Display, WMwindow, w, h);
  1016 
  1017 		/* Resize the fullscreen and display windows */
  1018 		if ( flags & SDL_FULLSCREEN ) {
  1019 			if ( screen->flags & SDL_FULLSCREEN ) {
  1020 				X11_ResizeFullScreen(this);
  1021 			} else {
  1022 				screen->flags |= SDL_FULLSCREEN;
  1023 				X11_EnterFullScreen(this);
  1024 			}
  1025 		} else {
  1026 			if ( screen->flags & SDL_FULLSCREEN ) {
  1027 				screen->flags &= ~SDL_FULLSCREEN;
  1028 				X11_LeaveFullScreen(this);
  1029 			}
  1030 		}
  1031 		XResizeWindow(SDL_Display, SDL_Window, w, h);
  1032 	}
  1033 	return(0);
  1034 }
  1035 
  1036 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current,
  1037 				int width, int height, int bpp, Uint32 flags)
  1038 {
  1039 	Uint32 saved_flags;
  1040 
  1041 	/* Lock the event thread, in multi-threading environments */
  1042 	SDL_Lock_EventThread();
  1043 
  1044 	/* Check the combination of flags we were passed */
  1045 	if ( flags & SDL_FULLSCREEN ) {
  1046 		/* Clear fullscreen flag if not supported */
  1047 		if ( SDL_windowid ) {
  1048 			flags &= ~SDL_FULLSCREEN;
  1049 		}
  1050 	}
  1051 
  1052 	/* Flush any delayed updates */
  1053 	XSync(GFX_Display, False);
  1054 
  1055 	/* Set up the X11 window */
  1056 	saved_flags = current->flags;
  1057 	if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL))
  1058 	      && (bpp == current->format->BitsPerPixel)
  1059           && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) {
  1060 		if (X11_ResizeWindow(this, current, width, height, flags) < 0) {
  1061 			current = NULL;
  1062 			goto done;
  1063 		}
  1064 	} else {
  1065 		if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) {
  1066 			current = NULL;
  1067 			goto done;
  1068 		}
  1069 	}
  1070 
  1071 	/* Set up the new mode framebuffer */
  1072 	if ( ((current->w != width) || (current->h != height)) ||
  1073              ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) {
  1074 		current->w = width;
  1075 		current->h = height;
  1076 		current->pitch = SDL_CalculatePitch(current);
  1077 		X11_ResizeImage(this, current, flags);
  1078 	}
  1079 	current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME));
  1080 
  1081   done:
  1082 	/* Release the event thread */
  1083 	XSync(SDL_Display, False);
  1084 	SDL_Unlock_EventThread();
  1085 
  1086 	/* We're done! */
  1087 	return(current);
  1088 }
  1089 
  1090 static int X11_ToggleFullScreen(_THIS, int on)
  1091 {
  1092 	Uint32 event_thread;
  1093 
  1094 	/* Don't switch if we don't own the window */
  1095 	if ( SDL_windowid ) {
  1096 		return(0);
  1097 	}
  1098 
  1099 	/* Don't lock if we are the event thread */
  1100 	event_thread = SDL_EventThreadID();
  1101 	if ( event_thread && (SDL_ThreadID() == event_thread) ) {
  1102 		event_thread = 0;
  1103 	}
  1104 	if ( event_thread ) {
  1105 		SDL_Lock_EventThread();
  1106 	}
  1107 	if ( on ) {
  1108 		this->screen->flags |= SDL_FULLSCREEN;
  1109 		X11_EnterFullScreen(this);
  1110 	} else {
  1111 		this->screen->flags &= ~SDL_FULLSCREEN;
  1112 		X11_LeaveFullScreen(this);
  1113 	}
  1114 	X11_RefreshDisplay(this);
  1115 	if ( event_thread ) {
  1116 		SDL_Unlock_EventThread();
  1117 	}
  1118 	SDL_ResetKeyboard();
  1119 	return(1);
  1120 }
  1121 
  1122 /* Update the current mouse state and position */
  1123 static void X11_UpdateMouse(_THIS)
  1124 {
  1125 	Window u1; int u2;
  1126 	Window current_win;
  1127 	int x, y;
  1128 	unsigned int mask;
  1129 
  1130 	/* Lock the event thread, in multi-threading environments */
  1131 	SDL_Lock_EventThread();
  1132 	if ( XQueryPointer(SDL_Display, SDL_Window, &u1, &current_win,
  1133 	                   &u2, &u2, &x, &y, &mask) ) {
  1134 		if ( (x >= 0) && (x < SDL_VideoSurface->w) &&
  1135 		     (y >= 0) && (y < SDL_VideoSurface->h) ) {
  1136 			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
  1137 			SDL_PrivateMouseMotion(0, 0, x, y);
  1138 		} else {
  1139 			SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
  1140 		}
  1141 	}
  1142 	SDL_Unlock_EventThread();
  1143 }
  1144 
  1145 /* simple colour distance metric. Supposed to be better than a plain
  1146    Euclidian distance anyway. */
  1147 #define COLOUR_FACTOR 3
  1148 #define LIGHT_FACTOR 1
  1149 #define COLOUR_DIST(r1, g1, b1, r2, g2, b2)				\
  1150 	(COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2))	\
  1151 	 + LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2)))
  1152 
  1153 static void allocate_nearest(_THIS, SDL_Color *colors,
  1154 			     SDL_Color *want, int nwant)
  1155 {
  1156 	/*
  1157 	 * There is no way to know which ones to choose from, so we retrieve
  1158 	 * the entire colormap and try the nearest possible, until we find one
  1159 	 * that is shared.
  1160 	 */
  1161 	XColor all[256];
  1162 	int i;
  1163 	for(i = 0; i < 256; i++)
  1164 		all[i].pixel = i;
  1165 	/* 
  1166 	 * XQueryColors sets the flags in the XColor struct, so we use
  1167 	 * that to keep track of which colours are available
  1168 	 */
  1169 	XQueryColors(GFX_Display, SDL_XColorMap, all, 256);
  1170 
  1171 	for(i = 0; i < nwant; i++) {
  1172 		XColor *c;
  1173 		int j;
  1174 		int best = 0;
  1175 		int mindist = 0x7fffffff;
  1176 		int ri = want[i].r;
  1177 		int gi = want[i].g;
  1178 		int bi = want[i].b;
  1179 		for(j = 0; j < 256; j++) {
  1180 			int rj, gj, bj, d2;
  1181 			if(!all[j].flags)
  1182 				continue;	/* unavailable colour cell */
  1183 			rj = all[j].red >> 8;
  1184 			gj = all[j].green >> 8;
  1185 			bj = all[j].blue >> 8;
  1186 			d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj);
  1187 			if(d2 < mindist) {
  1188 				mindist = d2;
  1189 				best = j;
  1190 			}
  1191 		}
  1192 		if(SDL_XPixels[best])
  1193 			continue; /* already allocated, waste no more time */
  1194 		c = all + best;
  1195 		if(XAllocColor(GFX_Display, SDL_XColorMap, c)) {
  1196 			/* got it */
  1197 			colors[c->pixel].r = c->red >> 8;
  1198 			colors[c->pixel].g = c->green >> 8;
  1199 			colors[c->pixel].b = c->blue >> 8;
  1200 			++SDL_XPixels[c->pixel];
  1201 		} else {
  1202 			/* 
  1203 			 * The colour couldn't be allocated, probably being
  1204 			 * owned as a r/w cell by another client. Flag it as
  1205 			 * unavailable and try again. The termination of the
  1206 			 * loop is guaranteed since at least black and white
  1207 			 * are always there.
  1208 			 */
  1209 			c->flags = 0;
  1210 			i--;
  1211 		}
  1212 	}
  1213 }
  1214 
  1215 int X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  1216 {
  1217 	int nrej = 0;
  1218 
  1219 	/* Check to make sure we have a colormap allocated */
  1220 	if ( SDL_XPixels == NULL ) {
  1221 		return(0);
  1222 	}
  1223 	if ( (this->screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) {
  1224 	        /* private writable colormap: just set the colours we need */
  1225 	        XColor  *xcmap;
  1226 		int i;
  1227 	        xcmap = SDL_stack_alloc(XColor, ncolors);
  1228 		if(xcmap == NULL)
  1229 		        return 0;
  1230 		for ( i=0; i<ncolors; ++i ) {
  1231 			xcmap[i].pixel = i + firstcolor;
  1232 			xcmap[i].red   = (colors[i].r<<8)|colors[i].r;
  1233 			xcmap[i].green = (colors[i].g<<8)|colors[i].g;
  1234 			xcmap[i].blue  = (colors[i].b<<8)|colors[i].b;
  1235 			xcmap[i].flags = (DoRed|DoGreen|DoBlue);
  1236 		}
  1237 		XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
  1238 		XSync(GFX_Display, False);
  1239 		SDL_stack_free(xcmap);
  1240 	} else {
  1241 	        /*
  1242 		 * Shared colormap: We only allocate read-only cells, which
  1243 		 * increases the likelyhood of colour sharing with other
  1244 		 * clients. The pixel values will almost certainly be
  1245 		 * different from the requested ones, so the user has to
  1246 		 * walk the colormap and see which index got what colour.
  1247 		 *
  1248 		 * We can work directly with the logical palette since it
  1249 		 * has already been set when we get here.
  1250 		 */
  1251 		SDL_Color *want, *reject;
  1252 	        unsigned long *freelist;
  1253 		int i;
  1254 		int nfree = 0;
  1255 		int nc = this->screen->format->palette->ncolors;
  1256 	        colors = this->screen->format->palette->colors;
  1257 		freelist = SDL_stack_alloc(unsigned long, nc);
  1258 		/* make sure multiple allocations of the same cell are freed */
  1259 	        for(i = 0; i < ncolors; i++) {
  1260 		        int pixel = firstcolor + i;
  1261 		        while(SDL_XPixels[pixel]) {
  1262 			        freelist[nfree++] = pixel;
  1263 				--SDL_XPixels[pixel];
  1264 			}
  1265 		}
  1266 		XFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0);
  1267 		SDL_stack_free(freelist);
  1268 
  1269 		want = SDL_stack_alloc(SDL_Color, ncolors);
  1270 		reject = SDL_stack_alloc(SDL_Color, ncolors);
  1271 		SDL_memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color));
  1272 		/* make sure the user isn't fooled by her own wishes
  1273 		   (black is safe, always available in the default colormap) */
  1274 		SDL_memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color));
  1275 
  1276 		/* now try to allocate the colours */
  1277 		for(i = 0; i < ncolors; i++) {
  1278 		        XColor col;
  1279 			col.red = want[i].r << 8;
  1280 			col.green = want[i].g << 8;
  1281 			col.blue = want[i].b << 8;
  1282 			col.flags = DoRed | DoGreen | DoBlue;
  1283 			if(XAllocColor(GFX_Display, SDL_XColorMap, &col)) {
  1284 			        /* We got the colour, or at least the nearest
  1285 				   the hardware could get. */
  1286 			        colors[col.pixel].r = col.red >> 8;
  1287 				colors[col.pixel].g = col.green >> 8;
  1288 				colors[col.pixel].b = col.blue >> 8;
  1289 				++SDL_XPixels[col.pixel];
  1290 			} else {
  1291 				/*
  1292 				 * no more free cells, add it to the list
  1293 				 * of rejected colours
  1294 				 */
  1295 				reject[nrej++] = want[i];
  1296 			}
  1297 		}
  1298 		if(nrej)
  1299 			allocate_nearest(this, colors, reject, nrej);
  1300 		SDL_stack_free(reject);
  1301 		SDL_stack_free(want);
  1302 	}
  1303 	return nrej == 0;
  1304 }
  1305 
  1306 int X11_SetGammaRamp(_THIS, Uint16 *ramp)
  1307 {
  1308 	int i, ncolors;
  1309 	XColor xcmap[256];
  1310 
  1311 	/* See if actually setting the gamma is supported */
  1312 	if ( SDL_Visual->class != DirectColor ) {
  1313 	    SDL_SetError("Gamma correction not supported on this visual");
  1314 	    return(-1);
  1315 	}
  1316 
  1317 	/* Calculate the appropriate palette for the given gamma ramp */
  1318 	ncolors = SDL_Visual->map_entries;
  1319 	for ( i=0; i<ncolors; ++i ) {
  1320 		Uint8 c = (256 * i / ncolors);
  1321 		xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
  1322 		xcmap[i].red   = ramp[0*256+c];
  1323 		xcmap[i].green = ramp[1*256+c];
  1324 		xcmap[i].blue  = ramp[2*256+c];
  1325 		xcmap[i].flags = (DoRed|DoGreen|DoBlue);
  1326 	}
  1327 	XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
  1328 	XSync(GFX_Display, False);
  1329 	return(0);
  1330 }
  1331 
  1332 /* Note:  If we are terminated, this could be called in the middle of
  1333    another SDL video routine -- notably UpdateRects.
  1334 */
  1335 void X11_VideoQuit(_THIS)
  1336 {
  1337 	/* Shutdown everything that's still up */
  1338 	/* The event thread should be done, so we can touch SDL_Display */
  1339 	if ( SDL_Display != NULL ) {
  1340 		/* Flush any delayed updates */
  1341 		XSync(GFX_Display, False);
  1342 
  1343 		/* Close the connection with the IM server */
  1344 		#ifdef X_HAVE_UTF8_STRING
  1345 		if (SDL_IC != NULL) {
  1346 			XDestroyIC(SDL_IC);
  1347 			SDL_IC = NULL;
  1348 		}
  1349 		if (SDL_IM != NULL) {
  1350 			XCloseIM(SDL_IM);
  1351 			SDL_IM = NULL;
  1352 		}
  1353 		#endif
  1354 
  1355 		/* Start shutting down the windows */
  1356 		X11_DestroyImage(this, this->screen);
  1357 		X11_DestroyWindow(this, this->screen);
  1358 		X11_FreeVideoModes(this);
  1359 		if ( SDL_XColorMap != SDL_DisplayColormap ) {
  1360 			XFreeColormap(SDL_Display, SDL_XColorMap);
  1361 		}
  1362 		if ( SDL_iconcolors ) {
  1363 			unsigned long pixel;
  1364 			Colormap dcmap = DefaultColormap(SDL_Display,
  1365 							 SDL_Screen);
  1366 			for(pixel = 0; pixel < 256; ++pixel) {
  1367 				while(SDL_iconcolors[pixel] > 0) {
  1368 					XFreeColors(GFX_Display,
  1369 						    dcmap, &pixel, 1, 0);
  1370 					--SDL_iconcolors[pixel];
  1371 				}
  1372 			}
  1373 			SDL_free(SDL_iconcolors);
  1374 			SDL_iconcolors = NULL;
  1375 		} 
  1376 
  1377 		/* Restore gamma settings if they've changed */
  1378 		if ( SDL_GetAppState() & SDL_APPACTIVE ) {
  1379 			X11_SwapVidModeGamma(this);
  1380 		}
  1381 
  1382 		/* Restore DPMS and screensaver settings */
  1383 		X11_RestoreScreenSaver(this, SDL_Display, screensaver_timeout, dpms_enabled);
  1384 
  1385 		/* Free that blank cursor */
  1386 		if ( SDL_BlankCursor != NULL ) {
  1387 			this->FreeWMCursor(this, SDL_BlankCursor);
  1388 			SDL_BlankCursor = NULL;
  1389 		}
  1390 
  1391 		/* Close the X11 graphics connection */
  1392 		if ( GFX_Display != NULL ) {
  1393 			XCloseDisplay(GFX_Display);
  1394 			GFX_Display = NULL;
  1395 		}
  1396 
  1397 		/* Close the X11 display connection */
  1398 		XCloseDisplay(SDL_Display);
  1399 		SDL_Display = NULL;
  1400 
  1401 		/* Reset the X11 error handlers */
  1402 		if ( XIO_handler ) {
  1403 			XSetIOErrorHandler(XIO_handler);
  1404 		}
  1405 		if ( X_handler ) {
  1406 			XSetErrorHandler(X_handler);
  1407 		}
  1408 
  1409 		/* Unload GL library after X11 shuts down */
  1410 		X11_GL_UnloadLibrary(this);
  1411 	}
  1412 	if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) {
  1413 		/* Direct screen access, no memory buffer */
  1414 		this->screen->pixels = NULL;
  1415 	}
  1416 
  1417 #if SDL_VIDEO_DRIVER_X11_XME
  1418     XiGMiscDestroy();
  1419 #endif
  1420 }
  1421