Home | History | Annotate | Download | only in x11
      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 (at) libsdl.org
     21 */
     22 #include "SDL_config.h"
     23 
     24 #include <X11/Xlib.h>
     25 #include <X11/Xutil.h>
     26 
     27 #include "SDL_version.h"
     28 #include "SDL_timer.h"
     29 #include "SDL_video.h"
     30 #include "SDL_syswm.h"
     31 #include "../SDL_pixels_c.h"
     32 #include "../../events/SDL_events_c.h"
     33 #include "SDL_x11modes_c.h"
     34 #include "SDL_x11wm_c.h"
     35 
     36 static Uint8 reverse_byte(Uint8 x)
     37 {
     38 	x = (x & 0xaa) >> 1 | (x & 0x55) << 1;
     39 	x = (x & 0xcc) >> 2 | (x & 0x33) << 2;
     40 	x = (x & 0xf0) >> 4 | (x & 0x0f) << 4;
     41 	return x;
     42 }
     43 
     44 void X11_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
     45 {
     46 	SDL_Surface *sicon;
     47 	XWMHints *wmhints;
     48 	XImage *icon_image;
     49 	Pixmap icon_pixmap;
     50 	Pixmap mask_pixmap;
     51 	Window icon_window = None;
     52 	GC gc;
     53 	XGCValues GCvalues;
     54 	int i, dbpp;
     55 	SDL_Rect bounds;
     56 	Uint8 *LSBmask;
     57 	Visual *dvis;
     58 	char *p;
     59 	int masksize;
     60 
     61 	SDL_Lock_EventThread();
     62 
     63 	/* The icon must use the default visual, depth and colormap of the
     64 	   screen, so it might need a conversion */
     65 	dvis = DefaultVisual(SDL_Display, SDL_Screen);
     66 	dbpp = DefaultDepth(SDL_Display, SDL_Screen);
     67 	for(i = 0; i < this->hidden->nvisuals; i++) {
     68 		if(this->hidden->visuals[i].visual == dvis) {
     69 			dbpp = this->hidden->visuals[i].bpp;
     70 			break;
     71 		}
     72 	}
     73 
     74 	/* The Visual struct is supposed to be opaque but we cheat a little */
     75 	sicon = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
     76 				     dbpp,
     77 				     dvis->red_mask, dvis->green_mask,
     78 				     dvis->blue_mask, 0);
     79 	if ( sicon == NULL )
     80 		goto done;
     81 
     82 	if(dbpp == 8) {
     83 		/* Default visual is 8bit; we need to allocate colours from
     84 		   the default colormap */
     85 		SDL_Color want[256], got[256];
     86 		int nwant;
     87 		Colormap dcmap;
     88 		int missing;
     89 		dcmap = DefaultColormap(SDL_Display, SDL_Screen);
     90 		if(icon->format->palette) {
     91 			/* The icon has a palette as well - we just have to
     92 			   find those colours */
     93 			nwant = icon->format->palette->ncolors;
     94 			SDL_memcpy(want, icon->format->palette->colors,
     95 			       nwant * sizeof want[0]);
     96 		} else {
     97 			/* try the standard 6x6x6 cube for lack of better
     98 			   ideas */
     99 			int r, g, b, i;
    100 			for(r = i = 0; r < 256; r += 0x33)
    101 				for(g = 0; g < 256; g += 0x33)
    102 					for(b = 0; b < 256; b += 0x33, i++) {
    103 						want[i].r = r;
    104 						want[i].g = g;
    105 						want[i].b = b;
    106 					}
    107 			nwant = 216;
    108 		}
    109 		if(SDL_iconcolors) {
    110 			/* free already allocated colours first */
    111 			unsigned long freelist[512];
    112 			int nfree = 0;
    113 			for(i = 0; i < 256; i++) {
    114 				while(SDL_iconcolors[i]) {
    115 					freelist[nfree++] = i;
    116 					SDL_iconcolors[i]--;
    117 				}
    118 			}
    119 			XFreeColors(GFX_Display, dcmap, freelist, nfree, 0);
    120 		}
    121 		if(!SDL_iconcolors)
    122 			SDL_iconcolors = SDL_malloc(256 * sizeof *SDL_iconcolors);
    123 		SDL_memset(SDL_iconcolors, 0, 256 * sizeof *SDL_iconcolors);
    124 
    125 		/* try to allocate the colours */
    126 		SDL_memset(got, 0, sizeof got);
    127 		missing = 0;
    128 		for(i = 0; i < nwant; i++) {
    129 			XColor c;
    130 			c.red = want[i].r << 8;
    131 			c.green = want[i].g << 8;
    132 			c.blue = want[i].b << 8;
    133 			c.flags = DoRed | DoGreen | DoBlue;
    134 			if(XAllocColor(GFX_Display, dcmap, &c)) {
    135 				/* got the colour */
    136 				SDL_iconcolors[c.pixel]++;
    137 				got[c.pixel] = want[i];
    138 			} else {
    139 				missing = 1;
    140 			}
    141 		}
    142 		if(missing) {
    143 			/* Some colours were apparently missing, so we just
    144 			   allocate all the rest as well */
    145 			XColor cols[256];
    146 			for(i = 0; i < 256; i++)
    147 				cols[i].pixel = i;
    148 			XQueryColors(GFX_Display, dcmap, cols, 256);
    149 			for(i = 0; i < 256; i++) {
    150 				got[i].r = cols[i].red >> 8;
    151 				got[i].g = cols[i].green >> 8;
    152 				got[i].b = cols[i].blue >> 8;
    153 				if(!SDL_iconcolors[i]) {
    154 					if(XAllocColor(GFX_Display, dcmap,
    155 							cols + i)) {
    156 						SDL_iconcolors[i] = 1;
    157 					} else {
    158 						/* index not available */
    159 						got[i].r = 0;
    160 						got[i].g = 0;
    161 						got[i].b = 0;
    162 					}
    163 				}
    164 			}
    165 		}
    166 
    167 		SDL_SetColors(sicon, got, 0, 256);
    168 	}
    169 
    170 	bounds.x = 0;
    171 	bounds.y = 0;
    172 	bounds.w = icon->w;
    173 	bounds.h = icon->h;
    174 	if ( SDL_LowerBlit(icon, &bounds, sicon, &bounds) < 0 )
    175 		goto done;
    176 
    177 	/* We need the mask as given, except in LSBfirst format instead of
    178 	   MSBfirst. Reverse the bits in each byte. */
    179 	masksize = ((sicon->w + 7) >> 3) * sicon->h;
    180 	LSBmask = SDL_malloc(masksize);
    181 	if ( LSBmask == NULL ) {
    182 		goto done;
    183 	}
    184 	SDL_memset(LSBmask, 0, masksize);
    185 	for(i = 0; i < masksize; i++)
    186 		LSBmask[i] = reverse_byte(mask[i]);
    187 	mask_pixmap = XCreatePixmapFromBitmapData(SDL_Display, WMwindow,
    188 						  (char *)LSBmask,
    189 						  sicon->w, sicon->h,
    190 						  1L, 0L, 1);
    191 
    192 	/* Transfer the image to an X11 pixmap */
    193 	icon_image = XCreateImage(SDL_Display,
    194 				  DefaultVisual(SDL_Display, SDL_Screen),
    195 				  DefaultDepth(SDL_Display, SDL_Screen),
    196 				  ZPixmap, 0, sicon->pixels,
    197 				  sicon->w, sicon->h,
    198 				  32, 0);
    199 	icon_image->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
    200 		                 ? MSBFirst : LSBFirst;
    201 	icon_pixmap = XCreatePixmap(SDL_Display, SDL_Root, sicon->w, sicon->h,
    202 				    DefaultDepth(SDL_Display, SDL_Screen));
    203 	gc = XCreateGC(SDL_Display, icon_pixmap, 0, &GCvalues);
    204 	XPutImage(SDL_Display, icon_pixmap, gc, icon_image,
    205 		  0, 0, 0, 0, sicon->w, sicon->h);
    206 	XFreeGC(SDL_Display, gc);
    207 	XDestroyImage(icon_image);
    208 	SDL_free(LSBmask);
    209 	sicon->pixels = NULL;
    210 
    211 	/* Some buggy window managers (some versions of Enlightenment, it
    212 	   seems) need an icon window *and* icon pixmap to work properly, while
    213 	   it screws up others. The default is only to use a pixmap. */
    214 	p = SDL_getenv("SDL_VIDEO_X11_ICONWIN");
    215 	if(p && *p) {
    216 		icon_window = XCreateSimpleWindow(SDL_Display, SDL_Root,
    217 						  0, 0, sicon->w, sicon->h, 0,
    218 						  CopyFromParent,
    219 						  CopyFromParent);
    220 		XSetWindowBackgroundPixmap(SDL_Display, icon_window,
    221 					   icon_pixmap);
    222 		XClearWindow(SDL_Display, icon_window);
    223 	}
    224 
    225 	/* Set the window icon to the icon pixmap (and icon window) */
    226 	wmhints = XAllocWMHints();
    227 	wmhints->flags = (IconPixmapHint | IconMaskHint);
    228 	wmhints->icon_pixmap = icon_pixmap;
    229 	wmhints->icon_mask = mask_pixmap;
    230 	if(icon_window != None) {
    231 		wmhints->flags |= IconWindowHint;
    232 		wmhints->icon_window = icon_window;
    233 	}
    234 	XSetWMHints(SDL_Display, WMwindow, wmhints);
    235 	XFree(wmhints);
    236 	XSync(SDL_Display, False);
    237 
    238   done:
    239 	SDL_Unlock_EventThread();
    240 	SDL_FreeSurface(sicon);
    241 }
    242 
    243 void X11_SetCaptionNoLock(_THIS, const char *title, const char *icon)
    244 {
    245 	XTextProperty titleprop, iconprop;
    246 	Status status;
    247 
    248 #ifdef X_HAVE_UTF8_STRING
    249 	Atom _NET_WM_NAME = 0;
    250 	Atom _NET_WM_ICON_NAME = 0;
    251 
    252 	/* Look up some useful Atoms */
    253 	if (SDL_X11_HAVE_UTF8) {
    254 		_NET_WM_NAME = XInternAtom(SDL_Display, "_NET_WM_NAME", False);
    255 		_NET_WM_ICON_NAME = XInternAtom(SDL_Display, "_NET_WM_ICON_NAME", False);
    256 	}
    257 #endif
    258 
    259 	if ( title != NULL ) {
    260 		char *title_locale = SDL_iconv_utf8_locale(title);
    261 		if ( !title_locale ) {
    262 			SDL_OutOfMemory();
    263 			return;
    264 		}
    265 		status = XStringListToTextProperty(&title_locale, 1, &titleprop);
    266 		SDL_free(title_locale);
    267 		if ( status ) {
    268 			XSetTextProperty(SDL_Display, WMwindow, &titleprop, XA_WM_NAME);
    269 			XFree(titleprop.value);
    270 		}
    271 #ifdef X_HAVE_UTF8_STRING
    272 		if (SDL_X11_HAVE_UTF8) {
    273 			status = Xutf8TextListToTextProperty(SDL_Display,
    274 					(char **)&title, 1, XUTF8StringStyle, &titleprop);
    275 			if ( status == Success ) {
    276 				XSetTextProperty(SDL_Display, WMwindow, &titleprop, _NET_WM_NAME);
    277 				XFree(titleprop.value);
    278 			}
    279 		}
    280 #endif
    281 	}
    282 	if ( icon != NULL ) {
    283 		char *icon_locale = SDL_iconv_utf8_locale(icon);
    284 		if ( !icon_locale ) {
    285 			SDL_OutOfMemory();
    286 			return;
    287 		}
    288 		status = XStringListToTextProperty(&icon_locale, 1, &iconprop);
    289 		SDL_free(icon_locale);
    290 		if ( status ) {
    291 			XSetTextProperty(SDL_Display, WMwindow, &iconprop, XA_WM_ICON_NAME);
    292 			XFree(iconprop.value);
    293 		}
    294 #ifdef X_HAVE_UTF8_STRING
    295 		if (SDL_X11_HAVE_UTF8) {
    296 			status = Xutf8TextListToTextProperty(SDL_Display,
    297 					(char **)&icon, 1, XUTF8StringStyle, &iconprop);
    298 			if ( status == Success ) {
    299 				XSetTextProperty(SDL_Display, WMwindow, &iconprop, _NET_WM_ICON_NAME);
    300 				XFree(iconprop.value);
    301 			}
    302 		}
    303 #endif
    304 	}
    305 	XSync(SDL_Display, False);
    306 }
    307 
    308 void X11_SetCaption(_THIS, const char *title, const char *icon)
    309 {
    310 	SDL_Lock_EventThread();
    311 	X11_SetCaptionNoLock(this, title, icon);
    312 	SDL_Unlock_EventThread();
    313 }
    314 
    315 /* Iconify the window */
    316 int X11_IconifyWindow(_THIS)
    317 {
    318 	int result;
    319 
    320 	SDL_Lock_EventThread();
    321 	result = XIconifyWindow(SDL_Display, WMwindow, SDL_Screen);
    322 	XSync(SDL_Display, False);
    323 	SDL_Unlock_EventThread();
    324 	return(result);
    325 }
    326 
    327 #if 0
    328 #define  D(...)  printf(__VA_ARGS__)
    329 #define  E(...)  D(__VA_ARGS__)
    330 #else
    331 #define  D(...)  ((void)0)
    332 #define  E(...)  ((void)0)
    333 #endif
    334 
    335 static void  set_window_pos_nolock(_THIS, int x, int y)
    336 {
    337     XWindowAttributes  attr;
    338     int          xNew, yNew;
    339     Window       child;
    340     int          xAdjust = X11_wmXAdjust;
    341     int          yAdjust = X11_wmYAdjust;
    342 
    343     /* don't do anything in full-screen mode, because the FSwindow is used
    344      * instead of the WMwindow, which will make the adjustment go wild
    345      */
    346     if (this->screen->flags & SDL_FULLSCREEN)
    347         return;
    348 
    349     /* this code is tricky because some window managers, but not all,
    350      * will translate the final window position by a given offset
    351      * corresponding to the frame decoration.
    352      *
    353      * so we first try to move the window, get the position that the
    354      * window manager has set, and if they are different, re-position the
    355      * window again with an adjustment.
    356      *
    357      * this causes a slight flicker since the window 'jumps' very
    358      * quickly from one position to the other.
    359      */
    360 
    361     D("%s: move to [%d,%d] adjusted to [%d,%d]\n", __FUNCTION__,
    362       x, y, x+xAdjust, y+yAdjust);
    363     XMoveWindow(SDL_Display, WMwindow, x + xAdjust, y + yAdjust);
    364     XSync(SDL_Display, True);
    365     XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, &xNew, &yNew, &child );
    366     if (xNew != x || yNew != y) {
    367         X11_wmXAdjust = xAdjust = x - xNew;
    368         X11_wmYAdjust = yAdjust = y - yNew;
    369         D("%s: read pos [%d,%d], recomputing adjust=[%d,%d] moving to [%d,%d]\n",
    370           __FUNCTION__, xNew, yNew, xAdjust, yAdjust, x+xAdjust, y+yAdjust);
    371         XMoveWindow(SDL_Display, WMwindow, x + xAdjust, y + yAdjust );
    372     }
    373     XSync(SDL_Display, False);
    374 }
    375 
    376 /* Set window position */
    377 void  X11_SetWindowPos(_THIS, int  x, int  y)
    378 {
    379     SDL_Lock_EventThread();
    380     set_window_pos_nolock(this, x, y);
    381     SDL_Unlock_EventThread();
    382 }
    383 
    384 /* Get window position */
    385 void  X11_GetWindowPos(_THIS, int  *px, int  *py)
    386 {
    387     /* in full-screen mode, you can't move the window */
    388     if (this->screen->flags & SDL_FULLSCREEN) {
    389         *px = *py = 0;
    390         return;
    391     }
    392 
    393 
    394     SDL_Lock_EventThread();
    395     {
    396         Window  child;
    397         Status  ret;
    398 
    399         XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, px, py, &child );
    400     }
    401     SDL_Unlock_EventThread();
    402 }
    403 
    404 static int
    405 is_window_visible(_THIS, int  screen_x, int  screen_y, int  screen_w, int  screen_h )
    406 {
    407     XWindowAttributes   attr;
    408     int                 x, y;
    409     Window              child;
    410 
    411     XGetWindowAttributes( SDL_Display, WMwindow, &attr );
    412     XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, &x, &y, &child );
    413 
    414     return ( x >= screen_x && x + attr.width  <= screen_x + screen_w  &&
    415              y >= screen_y && y + attr.height <= screen_y + screen_h );
    416 }
    417 
    418 int  X11_IsWindowVisible(_THIS, int  recenter)
    419 {
    420     int                 result = 0;
    421     XWindowAttributes   attr;
    422     int                 screen_w, screen_h;
    423 
    424     SDL_Lock_EventThread();
    425     XGetWindowAttributes( SDL_Display, SDL_Root, &attr );
    426     screen_w = attr.width;
    427     screen_h = attr.height;
    428 
    429 #if SDL_VIDEO_DRIVER_X11_XINERAMA
    430     if (use_xinerama) {
    431         SDL_NAME(XineramaScreenInfo) *xinerama;
    432         int                           i, screens;
    433 
    434         xinerama = SDL_NAME(XineramaQueryScreens)(SDL_Display, &screens);
    435         for (i = 0; i < screens; i++) {
    436             if ( is_window_visible( this,
    437                                     xinerama[i].x_org, xinerama[i].y_org,
    438                                     xinerama[i].width, xinerama[i].height ) )
    439             {
    440                 result = 1;
    441                 break;
    442             }
    443         }
    444 
    445         if ( !result && recenter ) {
    446             set_window_pos_nolock(this,
    447                               xinerama[0].x_org + (xinerama[0].width  - this->screen->w)/2,
    448                               xinerama[0].y_org + (xinerama[0].height - this->screen->h)/2 );
    449         }
    450         XFree(xinerama);
    451         goto Exit;
    452     }
    453 #endif
    454     if ( is_window_visible( this, 0, 0, screen_w, screen_h ) ) {
    455         result = 1;
    456     }
    457 
    458     if ( !result && recenter ) {
    459         set_window_pos_nolock( this,
    460                           (screen_w - this->screen->w)/2,
    461                           (screen_h - this->screen->h)/2 );
    462     }
    463 #ifdef SDL_VIDEO_DRIVER_X11_XINERAMA
    464 Exit:
    465 #endif
    466     SDL_Unlock_EventThread();
    467     return result;
    468 }
    469 
    470 SDL_GrabMode X11_GrabInputNoLock(_THIS, SDL_GrabMode mode)
    471 {
    472 	int result;
    473 
    474 	if ( this->screen == NULL ) {
    475 		return(SDL_GRAB_OFF);
    476 	}
    477 	if ( ! SDL_Window ) {
    478 		return(mode);	/* Will be set later on mode switch */
    479 	}
    480 	if ( mode == SDL_GRAB_OFF ) {
    481 		XUngrabPointer(SDL_Display, CurrentTime);
    482 		XUngrabKeyboard(SDL_Display, CurrentTime);
    483 	} else {
    484 		if ( this->screen->flags & SDL_FULLSCREEN ) {
    485 			/* Unbind the mouse from the fullscreen window */
    486 			XUngrabPointer(SDL_Display, CurrentTime);
    487 		}
    488 		/* Try to grab the mouse */
    489 #if 0 /* We'll wait here until we actually grab, otherwise behavior undefined */
    490 		for ( numtries = 0; numtries < 10; ++numtries ) {
    491 #else
    492 		for ( ; ; ) {
    493 #endif
    494 			result = XGrabPointer(SDL_Display, SDL_Window, True, 0,
    495 						GrabModeAsync, GrabModeAsync,
    496 						SDL_Window, None, CurrentTime);
    497 			if ( result == GrabSuccess ) {
    498 				break;
    499 			}
    500 			SDL_Delay(100);
    501 		}
    502 		if ( result != GrabSuccess ) {
    503 			/* Uh, oh, what do we do here? */ ;
    504 		}
    505 		/* Now grab the keyboard */
    506 		XGrabKeyboard(SDL_Display, WMwindow, True,
    507 				GrabModeAsync, GrabModeAsync, CurrentTime);
    508 
    509 		/* Raise the window if we grab the mouse */
    510 		if ( !(this->screen->flags & SDL_FULLSCREEN) )
    511 			XRaiseWindow(SDL_Display, WMwindow);
    512 
    513 		/* Make sure we register input focus */
    514 		SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
    515 		/* Since we grabbed the pointer, we have mouse focus, too. */
    516 		SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
    517 	}
    518 	XSync(SDL_Display, False);
    519 
    520 	return(mode);
    521 }
    522 
    523 SDL_GrabMode X11_GrabInput(_THIS, SDL_GrabMode mode)
    524 {
    525 	SDL_Lock_EventThread();
    526 	mode = X11_GrabInputNoLock(this, mode);
    527 	SDL_Unlock_EventThread();
    528 
    529 	return(mode);
    530 }
    531 
    532 #define  MM_PER_INCH  25.4
    533 
    534 int
    535 X11_GetMonitorDPI(_THIS, int  *px_dpi, int *py_dpi)
    536 {
    537     Display*      display = SDL_Display;
    538     int           screen  = XDefaultScreen(display);
    539     int           xdpi, ydpi;
    540 
    541     int  width     = XDisplayWidth(display, screen);
    542     int  width_mm  = XDisplayWidthMM(display, screen);
    543     int  height    = XDisplayHeight(display, screen);
    544     int  height_mm = XDisplayHeightMM(display, screen);
    545 
    546     if (width_mm <= 0 || height_mm <= 0) {
    547         return -1;
    548     }
    549 
    550     xdpi = (int)(width  * MM_PER_INCH / width_mm + 0.5);
    551     ydpi = (int)(height * MM_PER_INCH / height_mm + 0.5);
    552 
    553     if (xdpi < 20 || xdpi > 400 || ydpi < 20 || ydpi > 400) {
    554         return -1;
    555     }
    556 
    557     *px_dpi = xdpi;
    558     *py_dpi = ydpi;
    559 
    560     return 0;
    561 }
    562 
    563 int
    564 X11_GetMonitorRect(_THIS, SDL_Rect *rect)
    565 {
    566     Display*  display = SDL_Display;
    567     int       screen  = XDefaultScreen(display);
    568 
    569     rect->x = 0;
    570     rect->y = 0;
    571     rect->w = XDisplayWidth(display, screen);
    572     rect->h = XDisplayHeight(display, screen);
    573 
    574     return 0;
    575 }
    576 
    577 /* If 'info' is the right version, this function fills it and returns 1.
    578    Otherwise, in case of a version mismatch, it returns -1.
    579 */
    580 static void lock_display(void)
    581 {
    582 	SDL_Lock_EventThread();
    583 }
    584 static void unlock_display(void)
    585 {
    586 	/* Make sure any X11 transactions are completed */
    587 	SDL_VideoDevice *this = current_video;
    588 	XSync(SDL_Display, False);
    589 	SDL_Unlock_EventThread();
    590 }
    591 
    592 #include <stdio.h>
    593 int X11_GetWMInfo(_THIS, SDL_SysWMinfo *info)
    594 {
    595 	if ( info->version.major <= SDL_MAJOR_VERSION ) {
    596 		info->subsystem = SDL_SYSWM_X11;
    597 		info->info.x11.display = SDL_Display;
    598 		info->info.x11.window = SDL_Window;
    599 		if ( SDL_VERSIONNUM(info->version.major,
    600 		                    info->version.minor,
    601 		                    info->version.patch) >= 1002 ) {
    602 			info->info.x11.fswindow = FSwindow;
    603 			info->info.x11.wmwindow = WMwindow;
    604 		}
    605 
    606 
    607 		if ( SDL_VERSIONNUM(info->version.major,
    608 		                    info->version.minor,
    609 		                    info->version.patch) >= 1212 ) {
    610 			info->info.x11.gfxdisplay = GFX_Display;
    611 		}
    612 
    613 		info->info.x11.lock_func = lock_display;
    614 		info->info.x11.unlock_func = unlock_display;
    615 		return(1);
    616 	} else {
    617 		SDL_SetError("Application not compiled with SDL %d.%d\n",
    618 					SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
    619 		return(-1);
    620 	}
    621 }
    622