/
SDL_x11video.c
1387 lines (1246 loc) · 38.9 KB
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
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
*/
/* X11 based SDL video driver implementation.
Note: This implementation does not currently need X11 thread locking,
since the event thread uses a separate X connection and any
additional locking necessary is handled internally. However,
if full locking is neccessary, take a look at XInitThreads().
*/
#include <unistd.h>
#include <sys/ioctl.h>
#ifdef MTRR_SUPPORT
#include <asm/mtrr.h>
#include <sys/fcntl.h>
#endif
37
#include "SDL_endian.h"
38
39
40
41
#include "SDL_timer.h"
#include "SDL_thread.h"
#include "SDL_video.h"
#include "SDL_mouse.h"
42
43
44
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
45
46
47
48
49
50
51
52
53
#include "SDL_x11video.h"
#include "SDL_x11wm_c.h"
#include "SDL_x11mouse_c.h"
#include "SDL_x11events_c.h"
#include "SDL_x11modes_c.h"
#include "SDL_x11image_c.h"
#include "SDL_x11yuv_c.h"
#include "SDL_x11gl_c.h"
#include "SDL_x11gamma_c.h"
54
#include "../blank_cursor.h"
55
56
57
58
59
60
61
62
63
64
65
/* Initialization/Query functions */
static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat);
static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
static int X11_ToggleFullScreen(_THIS, int on);
static void X11_UpdateMouse(_THIS);
static int X11_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color *colors);
static int X11_SetGammaRamp(_THIS, Uint16 *ramp);
static void X11_VideoQuit(_THIS);
66
67
68
69
70
/* X11 driver bootstrap functions */
static int X11_Available(void)
{
71
72
73
74
75
76
77
Display *display = NULL;
if ( SDL_X11_LoadSymbols() ) {
display = pXOpenDisplay(NULL);
if ( display != NULL ) {
pXCloseDisplay(display);
}
SDL_X11_UnloadSymbols();
78
79
80
81
82
83
84
85
}
return(display != NULL);
}
static void X11_DeleteDevice(SDL_VideoDevice *device)
{
if ( device ) {
if ( device->hidden ) {
86
SDL_free(device->hidden);
87
88
}
if ( device->gl_data ) {
89
SDL_free(device->gl_data);
90
}
91
SDL_free(device);
92
SDL_X11_UnloadSymbols();
93
94
95
96
97
}
}
static SDL_VideoDevice *X11_CreateDevice(int devindex)
{
98
99
100
101
SDL_VideoDevice *device = NULL;
if ( SDL_X11_LoadSymbols() ) {
/* Initialize all variables that we clean on shutdown */
102
device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
103
if ( device ) {
104
SDL_memset(device, 0, (sizeof *device));
105
device->hidden = (struct SDL_PrivateVideoData *)
106
SDL_malloc((sizeof *device->hidden));
107
device->gl_data = (struct SDL_PrivateGLData *)
108
SDL_malloc((sizeof *device->gl_data));
109
110
111
112
113
114
115
}
if ( (device == NULL) || (device->hidden == NULL) ||
(device->gl_data == NULL) ) {
SDL_OutOfMemory();
X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */
return(0);
}
116
117
SDL_memset(device->hidden, 0, (sizeof *device->hidden));
SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
118
119
120
121
122
123
124
125
126
127
/* Set the driver flags */
device->handles_any_size = 1;
/* Set the function pointers */
device->VideoInit = X11_VideoInit;
device->ListModes = X11_ListModes;
device->SetVideoMode = X11_SetVideoMode;
device->ToggleFullScreen = X11_ToggleFullScreen;
device->UpdateMouse = X11_UpdateMouse;
128
#if SDL_VIDEO_DRIVER_X11_XV
129
device->CreateYUVOverlay = X11_CreateYUVOverlay;
130
#endif
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
device->SetColors = X11_SetColors;
device->UpdateRects = NULL;
device->VideoQuit = X11_VideoQuit;
device->AllocHWSurface = X11_AllocHWSurface;
device->CheckHWBlit = NULL;
device->FillHWRect = NULL;
device->SetHWColorKey = NULL;
device->SetHWAlpha = NULL;
device->LockHWSurface = X11_LockHWSurface;
device->UnlockHWSurface = X11_UnlockHWSurface;
device->FlipHWSurface = X11_FlipHWSurface;
device->FreeHWSurface = X11_FreeHWSurface;
device->SetGamma = X11_SetVidModeGamma;
device->GetGamma = X11_GetVidModeGamma;
device->SetGammaRamp = X11_SetGammaRamp;
device->GetGammaRamp = NULL;
147
#if SDL_VIDEO_OPENGL_GLX
148
149
150
151
152
device->GL_LoadLibrary = X11_GL_LoadLibrary;
device->GL_GetProcAddress = X11_GL_GetProcAddress;
device->GL_GetAttribute = X11_GL_GetAttribute;
device->GL_MakeCurrent = X11_GL_MakeCurrent;
device->GL_SwapBuffers = X11_GL_SwapBuffers;
153
#endif
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
device->SetCaption = X11_SetCaption;
device->SetIcon = X11_SetIcon;
device->IconifyWindow = X11_IconifyWindow;
device->GrabInput = X11_GrabInput;
device->GetWMInfo = X11_GetWMInfo;
device->FreeWMCursor = X11_FreeWMCursor;
device->CreateWMCursor = X11_CreateWMCursor;
device->ShowWMCursor = X11_ShowWMCursor;
device->WarpWMCursor = X11_WarpWMCursor;
device->CheckMouseMode = X11_CheckMouseMode;
device->InitOSKeymap = X11_InitOSKeymap;
device->PumpEvents = X11_PumpEvents;
device->free = X11_DeleteDevice;
}
169
170
171
172
173
174
175
176
177
178
179
180
181
return device;
}
VideoBootStrap X11_bootstrap = {
"x11", "X Window System",
X11_Available, X11_CreateDevice
};
/* Normal X11 error handler routine */
static int (*X_handler)(Display *, XErrorEvent *) = NULL;
static int x_errhandler(Display *d, XErrorEvent *e)
{
182
#if SDL_VIDEO_DRIVER_X11_VIDMODE
183
184
extern int vm_error;
#endif
185
#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
186
187
188
extern int dga_error;
#endif
189
#if SDL_VIDEO_DRIVER_X11_VIDMODE
190
191
192
193
194
195
196
197
198
199
200
/* VidMode errors are non-fatal. :) */
/* Are the errors offset by one from the error base?
e.g. the error base is 143, the code is 148, and the
actual error is XF86VidModeExtensionDisabled (4) ?
*/
if ( (vm_error >= 0) &&
(((e->error_code == BadRequest)&&(e->request_code == vm_error)) ||
((e->error_code > vm_error) &&
(e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) {
#ifdef XFREE86_DEBUG
{ char errmsg[1024];
201
pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
202
203
204
205
206
printf("VidMode error: %s\n", errmsg);
}
#endif
return(0);
}
207
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
208
209
#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
210
211
212
213
214
215
/* DGA errors can be non-fatal. :) */
if ( (dga_error >= 0) &&
((e->error_code > dga_error) &&
(e->error_code <= (dga_error+XF86DGANumberErrors))) ) {
#ifdef XFREE86_DEBUG
{ char errmsg[1024];
216
pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
217
218
219
220
221
printf("DGA error: %s\n", errmsg);
}
#endif
return(0);
}
222
#endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
return(X_handler(d,e));
}
/* X11 I/O error handler routine */
static int (*XIO_handler)(Display *) = NULL;
static int xio_errhandler(Display *d)
{
/* Ack! Lost X11 connection! */
/* We will crash if we try to clean up our display */
if ( current_video->hidden->Ximage ) {
SDL_VideoSurface->pixels = NULL;
}
current_video->hidden->X11_Display = NULL;
/* Continue with the standard X11 error handler */
return(XIO_handler(d));
}
243
244
245
246
247
248
249
250
251
static int (*Xext_handler)(Display *,char *,char *) = NULL;
static int xext_errhandler(Display *d, char *ext_name, char *reason)
{
#ifdef XFREE86_DEBUG
printf("Xext error inside SDL (may be harmless):\n");
printf(" Extension \"%s\" %s on display \"%s\".\n",
ext_name, reason, pXDisplayString(d));
#endif
252
if (SDL_strcmp(reason, "missing") == 0) {
253
254
255
256
257
258
259
260
261
262
263
264
/*
* Since the query itself, elsewhere, can handle a missing extension
* and the default behaviour in Xlib is to write to stderr, which
* generates unnecessary bug reports, we just ignore these.
*/
return 0;
}
/* Everything else goes to the default handler... */
return Xext_handler(d, ext_name, reason);
}
265
266
267
268
269
270
271
272
273
274
275
/* Find out what class name we should use */
static char *get_classname(char *classname, int maxlen)
{
char *spot;
#if defined(linux) || defined(__FreeBSD__)
char procfile[1024];
char linkfile[1024];
int linksize;
#endif
/* First allow environment variable override */
276
spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS");
277
if ( spot ) {
278
SDL_strlcpy(classname, spot, maxlen);
279
280
281
282
283
284
return classname;
}
/* Next look at the application's executable name */
#if defined(linux) || defined(__FreeBSD__)
#if defined(linux)
285
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid());
286
#elif defined(__FreeBSD__)
287
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file", getpid());
288
289
290
291
292
293
#else
#error Where can we find the executable name?
#endif
linksize = readlink(procfile, linkfile, sizeof(linkfile)-1);
if ( linksize > 0 ) {
linkfile[linksize] = '\0';
294
spot = SDL_strrchr(linkfile, '/');
295
if ( spot ) {
296
SDL_strlcpy(classname, spot+1, maxlen);
297
} else {
298
SDL_strlcpy(classname, linkfile, maxlen);
299
300
301
302
303
304
}
return classname;
}
#endif /* linux */
/* Finally use the default we've used forever */
305
SDL_strlcpy(classname, "SDL_App", maxlen);
306
307
308
return classname;
}
309
310
311
/* Create auxiliary (toplevel) windows with the current visual */
static void create_aux_windows(_THIS)
{
312
char classname[1024];
313
314
315
316
317
318
319
320
XSetWindowAttributes xattr;
XWMHints *hints;
XTextProperty titleprop, iconprop;
int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
/* Don't create any extra windows if we are being managed */
if ( SDL_windowid ) {
FSwindow = 0;
321
WMwindow = SDL_strtol(SDL_windowid, NULL, 0);
322
323
324
325
return;
}
if(FSwindow)
326
pXDestroyWindow(SDL_Display, FSwindow);
327
328
329
330
331
332
xattr.override_redirect = True;
xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
xattr.border_pixel = 0;
xattr.colormap = SDL_XColorMap;
333
FSwindow = pXCreateWindow(SDL_Display, SDL_Root,
334
xinerama_x, xinerama_y, 32, 32, 0,
335
336
337
338
339
this->hidden->depth, InputOutput, SDL_Visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel
| CWColormap,
&xattr);
340
pXSelectInput(SDL_Display, FSwindow, StructureNotifyMask);
341
342
343
344
345
346
/* Tell KDE to keep the fullscreen window on top */
{
XEvent ev;
long mask;
347
SDL_memset(&ev, 0, sizeof(ev));
348
349
ev.xclient.type = ClientMessage;
ev.xclient.window = SDL_Root;
350
ev.xclient.message_type = pXInternAtom(SDL_Display,
351
352
353
354
355
"KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = FSwindow;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
356
pXSendEvent(SDL_Display, SDL_Root, False, mask, &ev);
357
358
359
360
361
362
}
hints = NULL;
titleprop.value = iconprop.value = NULL;
if(WMwindow) {
/* All window attributes must survive the recreation */
363
364
365
366
hints = pXGetWMHints(SDL_Display, WMwindow);
pXGetWMName(SDL_Display, WMwindow, &titleprop);
pXGetWMIconName(SDL_Display, WMwindow, &iconprop);
pXDestroyWindow(SDL_Display, WMwindow);
367
368
369
370
}
/* Create the window for windowed management */
/* (reusing the xattr structure above) */
371
WMwindow = pXCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0,
372
373
374
375
376
377
this->hidden->depth, InputOutput, SDL_Visual,
CWBackPixel | CWBorderPixel | CWColormap,
&xattr);
/* Set the input hints so we get keyboard input */
if(!hints) {
378
hints = pXAllocWMHints();
379
380
381
hints->input = True;
hints->flags = InputHint;
}
382
383
pXSetWMHints(SDL_Display, WMwindow, hints);
pXFree(hints);
384
if(titleprop.value) {
385
386
pXSetWMName(SDL_Display, WMwindow, &titleprop);
pXFree(titleprop.value);
387
388
}
if(iconprop.value) {
389
390
pXSetWMIconName(SDL_Display, WMwindow, &iconprop);
pXFree(iconprop.value);
391
392
}
393
pXSelectInput(SDL_Display, WMwindow,
394
395
396
397
FocusChangeMask | KeyPressMask | KeyReleaseMask
| PropertyChangeMask | StructureNotifyMask | KeymapStateMask);
/* Set the class hints so we can get an icon (AfterStep) */
398
get_classname(classname, sizeof(classname));
399
400
{
XClassHint *classhints;
401
classhints = pXAllocClassHint();
402
if(classhints != NULL) {
403
404
classhints->res_name = classname;
classhints->res_class = classname;
405
406
pXSetClassHint(SDL_Display, WMwindow, classhints);
pXFree(classhints);
407
408
409
}
}
410
411
412
413
414
/* Setup the communication with the IM server */
SDL_IM = NULL;
SDL_IC = NULL;
#ifdef X_HAVE_UTF8_STRING
415
SDL_IM = pXOpenIM(SDL_Display, NULL, classname, classname);
416
417
418
419
420
421
422
if (SDL_IM == NULL) {
SDL_SetError("no input method could be opened");
} else {
SDL_IC = pXCreateIC(SDL_IM,
XNClientWindow, WMwindow,
XNFocusWindow, WMwindow,
XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
423
424
XNResourceName, classname,
XNResourceClass, classname,
425
426
427
428
429
430
431
432
433
NULL);
if (SDL_IC == NULL) {
SDL_SetError("no input context could be created");
pXCloseIM(SDL_IM);
SDL_IM = NULL;
}
}
#endif
434
/* Allow the window to be deleted by the window manager */
435
436
WM_DELETE_WINDOW = pXInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);
pXSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
437
438
439
440
441
442
443
444
445
446
}
static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
char *display;
int i;
/* Open the X11 display */
display = NULL; /* Get it from DISPLAY environment variable */
447
448
if ( (SDL_strncmp(pXDisplayName(display), ":", 1) == 0) ||
(SDL_strncmp(pXDisplayName(display), "unix:", 5) == 0) ) {
449
450
451
452
local_X11 = 1;
} else {
local_X11 = 0;
}
453
SDL_Display = pXOpenDisplay(display);
454
#if defined(__osf__) && defined(SDL_VIDEO_DRIVER_X11_DYNAMIC)
455
456
457
458
459
460
461
462
463
464
465
466
467
/* On Tru64 if linking without -lX11, it fails and you get following message.
* Xlib: connection to ":0.0" refused by server
* Xlib: XDM authorization key matches an existing client!
*
* It succeeds if retrying 1 second later
* or if running xhost +localhost on shell.
*
*/
if ( SDL_Display == NULL ) {
SDL_Delay(1000);
SDL_Display = pXOpenDisplay(display);
}
#endif
468
469
470
471
472
if ( SDL_Display == NULL ) {
SDL_SetError("Couldn't open X11 display");
return(-1);
}
#ifdef X11_DEBUG
473
pXSynchronize(SDL_Display, True);
474
475
476
477
478
479
#endif
/* Create an alternate X display for graphics updates -- allows us
to do graphics updates in a separate thread from event handling.
Thread-safe X11 doesn't seem to exist.
*/
480
GFX_Display = pXOpenDisplay(display);
481
482
483
484
485
486
if ( GFX_Display == NULL ) {
SDL_SetError("Couldn't open X11 display");
return(-1);
}
/* Set the normal X error handler */
487
X_handler = pXSetErrorHandler(x_errhandler);
488
489
/* Set the error handler if we lose the X display */
490
XIO_handler = pXSetIOErrorHandler(xio_errhandler);
491
492
493
494
/* Set the X extension error handler */
Xext_handler = pXSetExtensionErrorHandler(xext_errhandler);
495
496
497
498
499
/* use default screen (from $DISPLAY) */
SDL_Screen = DefaultScreen(SDL_Display);
#ifndef NO_SHARED_MEMORY
/* Check for MIT shared memory extension */
500
use_mitshm = 0;
501
if ( local_X11 ) {
502
use_mitshm = pXShmQueryExtension(SDL_Display);
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
}
#endif /* NO_SHARED_MEMORY */
/* Get the available video modes */
if(X11_GetVideoModes(this) < 0)
return -1;
/* Determine the default screen depth:
Use the default visual (or at least one with the same depth) */
SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen);
for(i = 0; i < this->hidden->nvisuals; i++)
if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display,
SDL_Screen))
break;
if(i == this->hidden->nvisuals) {
/* default visual was useless, take the deepest one instead */
i = 0;
}
SDL_Visual = this->hidden->visuals[i].visual;
if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) {
SDL_XColorMap = SDL_DisplayColormap;
} else {
525
SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root,
526
527
528
529
530
531
532
533
534
535
536
537
SDL_Visual, AllocNone);
}
this->hidden->depth = this->hidden->visuals[i].depth;
vformat->BitsPerPixel = this->hidden->visuals[i].bpp;
if ( vformat->BitsPerPixel > 8 ) {
vformat->Rmask = SDL_Visual->red_mask;
vformat->Gmask = SDL_Visual->green_mask;
vformat->Bmask = SDL_Visual->blue_mask;
}
X11_SaveVidModeGamma(this);
/* See if we have been passed a window to use */
538
SDL_windowid = SDL_getenv("SDL_WINDOWID");
539
540
541
542
543
544
545
546
547
548
549
550
551
/* Create the fullscreen and managed windows */
create_aux_windows(this);
/* Create the blank cursor */
SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
BLANK_CWIDTH, BLANK_CHEIGHT,
BLANK_CHOTX, BLANK_CHOTY);
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
/* We're done! */
552
pXFlush(SDL_Display);
553
554
555
556
557
558
559
560
561
562
563
564
565
566
return(0);
}
static void X11_DestroyWindow(_THIS, SDL_Surface *screen)
{
/* Clean up OpenGL */
if ( screen ) {
screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT);
}
X11_GL_Shutdown(this);
if ( ! SDL_windowid ) {
/* Hide the managed window */
if ( WMwindow ) {
567
pXUnmapWindow(SDL_Display, WMwindow);
568
569
570
571
572
573
574
575
}
if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
screen->flags &= ~SDL_FULLSCREEN;
X11_LeaveFullScreen(this);
}
/* Destroy the output window */
if ( SDL_Window ) {
576
pXDestroyWindow(SDL_Display, SDL_Window);
577
578
579
580
581
582
583
584
585
}
/* Free the colormap entries */
if ( SDL_XPixels ) {
int numcolors;
unsigned long pixel;
numcolors = SDL_Visual->map_entries;
for ( pixel=0; pixel<numcolors; ++pixel ) {
while ( SDL_XPixels[pixel] > 0 ) {
586
pXFreeColors(GFX_Display,
587
588
589
590
SDL_DisplayColormap,&pixel,1,0);
--SDL_XPixels[pixel];
}
}
591
SDL_free(SDL_XPixels);
592
593
594
595
596
SDL_XPixels = NULL;
}
/* Free the graphics context */
if ( SDL_GC ) {
597
pXFreeGC(SDL_Display, SDL_GC);
598
599
600
601
602
SDL_GC = 0;
}
}
}
603
604
static SDL_bool X11_WindowPosition(_THIS, int *x, int *y, int w, int h)
{
605
606
const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
const char *center = SDL_getenv("SDL_VIDEO_CENTERED");
607
if ( window ) {
608
if ( SDL_sscanf(window, "%d,%d", x, y) == 2 ) {
609
610
return SDL_TRUE;
}
611
if ( SDL_strcmp(window, "center") == 0 ) {
612
613
614
615
616
617
618
619
620
621
622
center = window;
}
}
if ( center ) {
*x = (DisplayWidth(SDL_Display, SDL_Screen) - w)/2;
*y = (DisplayHeight(SDL_Display, SDL_Screen) - h)/2;
return SDL_TRUE;
}
return SDL_FALSE;
}
623
624
625
626
static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags)
{
XSizeHints *hints;
627
hints = pXAllocSizeHints();
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
if ( hints ) {
if ( flags & SDL_RESIZABLE ) {
hints->min_width = 32;
hints->min_height = 32;
hints->max_height = 4096;
hints->max_width = 4096;
} else {
hints->min_width = hints->max_width = w;
hints->min_height = hints->max_height = h;
}
hints->flags = PMaxSize | PMinSize;
if ( flags & SDL_FULLSCREEN ) {
hints->x = 0;
hints->y = 0;
hints->flags |= USPosition;
} else
/* Center it, if desired */
645
if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) {
646
hints->flags |= USPosition;
647
pXMoveWindow(SDL_Display, WMwindow, hints->x, hints->y);
648
649
/* Flush the resize event so we don't catch it later */
650
pXSync(SDL_Display, True);
651
}
652
653
pXSetWMNormalHints(SDL_Display, WMwindow, hints);
pXFree(hints);
654
655
656
657
658
659
660
661
662
663
664
}
/* Respect the window caption style */
if ( flags & SDL_NOFRAME ) {
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to set MWM hints */
665
WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
666
667
668
669
670
671
672
673
674
675
if ( WM_HINTS != None ) {
/* Hints used by Motif compliant window managers */
struct {
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} MWMHints = { (1L << 1), 0, 0, 0, 0 };
676
pXChangeProperty(SDL_Display, WMwindow,
677
678
679
680
681
682
683
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *)&MWMHints,
sizeof(MWMHints)/sizeof(long));
set = SDL_TRUE;
}
/* Now try to set KWM hints */
684
WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
685
686
687
if ( WM_HINTS != None ) {
long KWMHints = 0;
688
pXChangeProperty(SDL_Display, WMwindow,
689
690
691
692
693
694
695
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *)&KWMHints,
sizeof(KWMHints)/sizeof(long));
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
696
WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True);
697
698
699
if ( WM_HINTS != None ) {
long GNOMEHints = 0;
700
pXChangeProperty(SDL_Display, WMwindow,
701
702
703
704
705
706
707
708
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *)&GNOMEHints,
sizeof(GNOMEHints)/sizeof(long));
set = SDL_TRUE;
}
/* Finally set the transient hints if necessary */
if ( ! set ) {
709
pXSetTransientForHint(SDL_Display, WMwindow, SDL_Root);
710
711
712
713
714
715
716
717
718
}
} else {
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to unset MWM hints */
719
WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
720
if ( WM_HINTS != None ) {
721
pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
722
723
724
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
725
WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
726
if ( WM_HINTS != None ) {
727
pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
728
729
730
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
731
WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True);
732
if ( WM_HINTS != None ) {
733
pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
734
735
736
737
738
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if ( ! set ) {
/* NOTE: Does this work? */
739
pXSetTransientForHint(SDL_Display, WMwindow, None);
740
741
742
743
744
745
746
747
748
749
750
751
752
753
}
}
}
static int X11_CreateWindow(_THIS, SDL_Surface *screen,
int w, int h, int bpp, Uint32 flags)
{
int i, depth;
Visual *vis;
int vis_change;
/* If a window is already present, destroy it and start fresh */
if ( SDL_Window ) {
X11_DestroyWindow(this, screen);
754
switch_waiting = 0; /* Prevent jump back to now-meaningless state. */
755
756
757
758
}
/* See if we have been given a window id */
if ( SDL_windowid ) {
759
SDL_Window = SDL_strtol(SDL_windowid, NULL, 0);
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
} else {
SDL_Window = 0;
}
/* find out which visual we are going to use */
if ( flags & SDL_OPENGL ) {
XVisualInfo *vi;
vi = X11_GL_GetVisual(this);
if( !vi ) {
return -1;
}
vis = vi->visual;
depth = vi->depth;
} else if ( SDL_windowid ) {
XWindowAttributes a;
777
pXGetWindowAttributes(SDL_Display, SDL_Window, &a);
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
vis = a.visual;
depth = a.depth;
} else {
for ( i = 0; i < this->hidden->nvisuals; i++ ) {
if ( this->hidden->visuals[i].bpp == bpp )
break;
}
if ( i == this->hidden->nvisuals ) {
SDL_SetError("No matching visual for requested depth");
return -1; /* should never happen */
}
vis = this->hidden->visuals[i].visual;
depth = this->hidden->visuals[i].depth;
}
#ifdef X11_DEBUG
printf("Choosing %s visual at %d bpp - %d colormap entries\n", vis->class == PseudoColor ? "PseudoColor" : (vis->class == TrueColor ? "TrueColor" : (vis->class == DirectColor ? "DirectColor" : "Unknown")), depth, vis->map_entries);
#endif
vis_change = (vis != SDL_Visual);
SDL_Visual = vis;
this->hidden->depth = depth;
/* Allocate the new pixel format for this video mode */
if ( ! SDL_ReallocFormat(screen, bpp,
vis->red_mask, vis->green_mask, vis->blue_mask, 0) )
return -1;
/* Create the appropriate colormap */
if ( SDL_XColorMap != SDL_DisplayColormap ) {
806
pXFreeColormap(SDL_Display, SDL_XColorMap);
807
808
809
810
811
812
}
if ( SDL_Visual->class == PseudoColor ) {
int ncolors;
/* Allocate the pixel flags */
ncolors = SDL_Visual->map_entries;
813
SDL_XPixels = SDL_malloc(ncolors * sizeof(int));
814
815
816
817
if(SDL_XPixels == NULL) {
SDL_OutOfMemory();
return -1;
}
818
SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels));
819
820
821
822
823
824
825
/* always allocate a private colormap on non-default visuals */
if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) {
flags |= SDL_HWPALETTE;
}
if ( flags & SDL_HWPALETTE ) {
screen->flags |= SDL_HWPALETTE;
826
SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root,
827
828
829
830
831
832
833
SDL_Visual, AllocAll);
} else {
SDL_XColorMap = SDL_DisplayColormap;
}
} else if ( SDL_Visual->class == DirectColor ) {
/* Create a colormap which we can manipulate for gamma */
834
SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root,
835
SDL_Visual, AllocAll);
836
pXSync(SDL_Display, False);
837
838
839
840
841
842
843
844
/* Initialize the colormap to the identity mapping */
SDL_GetGammaRamp(0, 0, 0);
this->screen = screen;
X11_SetGammaRamp(this, this->gamma);
this->screen = NULL;
} else {
/* Create a read-only colormap for our window */
845
SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root,
846
847
848
849
850
851
852
853
854
855
856
857
SDL_Visual, AllocNone);
}
/* Recreate the auxiliary windows, if needed (required for GL) */
if ( vis_change )
create_aux_windows(this);
if(screen->flags & SDL_HWPALETTE) {
/* Since the full-screen window might have got a nonzero background
colour (0 is white on some displays), we should reset the
background to 0 here since that is what the user expects
with a private colormap */
858
859
pXSetWindowBackground(SDL_Display, FSwindow, 0);
pXClearWindow(SDL_Display, FSwindow);
860
861
862
863
864
865
866
}
/* resize the (possibly new) window manager window */
if( !SDL_windowid ) {
X11_SetSizeHints(this, w, h, flags);
current_w = w;
current_h = h;
867
pXResizeWindow(SDL_Display, WMwindow, w, h);
868
869
870
871
872
873
874
875
876
877
878
879
880
881
}
/* Create (or use) the X11 display window */
if ( !SDL_windowid ) {
if ( flags & SDL_OPENGL ) {
if ( X11_GL_CreateWindow(this, w, h) < 0 ) {
return(-1);
}
} else {
XSetWindowAttributes swa;
swa.background_pixel = 0;
swa.border_pixel = 0;
swa.colormap = SDL_XColorMap;
882
SDL_Window = pXCreateWindow(SDL_Display, WMwindow,
883
884
885
886
887
888
0, 0, w, h, 0, depth,
InputOutput, SDL_Visual,
CWBackPixel | CWBorderPixel
| CWColormap, &swa);
}
/* Only manage our input if we own the window */
889
pXSelectInput(SDL_Display, SDL_Window,
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
( EnterWindowMask | LeaveWindowMask
| ButtonPressMask | ButtonReleaseMask
| PointerMotionMask | ExposureMask ));
}
/* Create the graphics context here, once we have a window */
if ( flags & SDL_OPENGL ) {
if ( X11_GL_CreateContext(this) < 0 ) {
return(-1);
} else {
screen->flags |= SDL_OPENGL;
}
} else {
XGCValues gcv;
gcv.graphics_exposures = False;
905
SDL_GC = pXCreateGC(SDL_Display, SDL_Window,
906
907
908
909
910
911
912
913
914
GCGraphicsExposures, &gcv);
if ( ! SDL_GC ) {
SDL_SetError("Couldn't create graphics context");
return(-1);
}
}
/* Set our colormaps when not setting a GL mode */
if ( ! (flags & SDL_OPENGL) ) {
915
pXSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
916
if( !SDL_windowid ) {
917
918
pXSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap);
pXSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap);
919
920
921
922
}
}
#if 0 /* This is an experiment - are the graphics faster now? - nope. */
923
if ( SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE") )
924
925
926
927
928
929
930
931
932
#endif
/* Cache the window in the server, when possible */
{
Screen *xscreen;
XSetWindowAttributes a;
xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen);
a.backing_store = DoesBackingStore(xscreen);
if ( a.backing_store != NotUseful ) {
933
pXChangeWindowAttributes(SDL_Display, SDL_Window,
934
935
936
937
938
CWBackingStore, &a);
}
}
/* Update the internal keyboard state */
939
X11_SetKeyboardState(SDL_Display, NULL);
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
/* When the window is first mapped, ignore non-modifier keys */
{
Uint8 *keys = SDL_GetKeyState(NULL);
for ( i = 0; i < SDLK_LAST; ++i ) {
switch (i) {
case SDLK_NUMLOCK:
case SDLK_CAPSLOCK:
case SDLK_LCTRL:
case SDLK_RCTRL:
case SDLK_LSHIFT:
case SDLK_RSHIFT:
case SDLK_LALT:
case SDLK_RALT:
case SDLK_LMETA:
case SDLK_RMETA:
case SDLK_MODE:
break;
default:
keys[i] = SDL_RELEASED;
break;
}
}
}
965
966
/* Map them both and go fullscreen, if requested */
if ( ! SDL_windowid ) {
967
968
pXMapWindow(SDL_Display, SDL_Window);
pXMapWindow(SDL_Display, WMwindow);
969
X11_WaitMapped(this, WMwindow);
970
971
972
973
974
975
976
if ( flags & SDL_FULLSCREEN ) {
screen->flags |= SDL_FULLSCREEN;
X11_EnterFullScreen(this);
} else {
screen->flags &= ~SDL_FULLSCREEN;
}
}
977
978
979
980
981
982
983
984
985
986
987
988
return(0);
}
static int X11_ResizeWindow(_THIS,
SDL_Surface *screen, int w, int h, Uint32 flags)
{
if ( ! SDL_windowid ) {
/* Resize the window manager window */
X11_SetSizeHints(this, w, h, flags);
current_w = w;
current_h = h;
989
pXResizeWindow(SDL_Display, WMwindow, w, h);
990
991
992
993
994
995
996
997
998
999
1000
/* Resize the fullscreen and display windows */
if ( flags & SDL_FULLSCREEN ) {
if ( screen->flags & SDL_FULLSCREEN ) {
X11_ResizeFullScreen(this);
} else {
screen->flags |= SDL_FULLSCREEN;
X11_EnterFullScreen(this);
}
} else {
if ( screen->flags & SDL_FULLSCREEN ) {