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