This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_x11window.c
1105 lines (971 loc) · 34.4 KB
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
22
*/
#include "SDL_config.h"
23
24
#if SDL_VIDEO_DRIVER_X11
25
#include "../SDL_sysvideo.h"
26
#include "../SDL_pixels_c.h"
27
#include "../../events/SDL_keyboard_c.h"
28
#include "../../events/SDL_mouse_c.h"
29
30
#include "SDL_x11video.h"
31
#include "SDL_x11mouse.h"
32
#include "SDL_x11shape.h"
33
34
35
36
37
#ifdef SDL_VIDEO_DRIVER_PANDORA
#include "SDL_x11opengles.h"
#endif
38
#include "SDL_timer.h"
39
40
#include "SDL_syswm.h"
41
42
43
44
#define _NET_WM_STATE_REMOVE 0l
#define _NET_WM_STATE_ADD 1l
#define _NET_WM_STATE_TOGGLE 2l
45
static SDL_bool
46
X11_IsWindowOldFullscreen(_THIS, SDL_Window * window)
47
{
48
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
49
50
51
52
53
54
55
56
57
/* ICCCM2.0-compliant window managers can handle fullscreen windows */
if ((window->flags & SDL_WINDOW_FULLSCREEN) && !videodata->net_wm) {
return SDL_TRUE;
} else {
return SDL_FALSE;
}
}
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
static SDL_bool
X11_IsWindowMapped(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
XWindowAttributes attr;
XGetWindowAttributes(videodata->display, data->xwindow, &attr);
if (attr.map_state != IsUnmapped) {
return SDL_TRUE;
} else {
return SDL_FALSE;
}
}
static int
X11_GetWMStateProperty(_THIS, SDL_Window * window, Atom atoms[3])
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
int count = 0;
if (window->flags & SDL_WINDOW_FULLSCREEN) {
atoms[count++] = data->_NET_WM_STATE_FULLSCREEN;
}
if (window->flags & SDL_WINDOW_MAXIMIZED) {
atoms[count++] = data->_NET_WM_STATE_MAXIMIZED_VERT;
atoms[count++] = data->_NET_WM_STATE_MAXIMIZED_HORZ;
}
return count;
}
89
90
91
92
93
static void
X11_GetDisplaySize(_THIS, SDL_Window * window, int *w, int *h)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
SDL_DisplayData *displaydata =
94
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
95
96
XWindowAttributes attr;
97
98
99
100
101
102
103
104
105
XGetWindowAttributes(data->display, RootWindow(data->display, displaydata->screen), &attr);
if (window->flags & SDL_WINDOW_FULLSCREEN) {
/* The bounds when this window is visible is the fullscreen mode */
SDL_DisplayMode fullscreen_mode;
if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
attr.width = fullscreen_mode.w;
attr.height = fullscreen_mode.h;
}
}
106
107
108
109
110
111
112
113
if (w) {
*w = attr.width;
}
if (h) {
*h = attr.height;
}
}
114
115
116
117
118
119
static int
SetupWindowData(_THIS, SDL_Window * window, Window w, BOOL created)
{
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data;
int numwindows = videodata->numwindows;
120
int windowlistlength = videodata->windowlistlength;
121
122
123
SDL_WindowData **windowlist = videodata->windowlist;
/* Allocate the window data */
124
data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));
125
126
127
128
if (!data) {
SDL_OutOfMemory();
return -1;
}
129
130
data->window = window;
data->xwindow = w;
131
132
133
134
135
136
137
138
139
140
141
142
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
data->ic =
pXCreateIC(videodata->im, XNClientWindow, w, XNFocusWindow, w,
XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNResourceName, videodata->classname, XNResourceClass,
videodata->classname, NULL);
}
#endif
data->created = created;
data->videodata = videodata;
143
144
/* Associate the data with the window */
145
146
147
if (numwindows < windowlistlength) {
windowlist[numwindows] = data;
videodata->numwindows++;
148
} else {
149
150
151
152
153
154
155
156
157
158
159
160
161
windowlist =
(SDL_WindowData **) SDL_realloc(windowlist,
(numwindows +
1) * sizeof(*windowlist));
if (!windowlist) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
windowlist[numwindows] = data;
videodata->numwindows++;
videodata->windowlistlength++;
videodata->windowlist = windowlist;
162
163
}
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/* Fill in the SDL window with the window data */
{
XWindowAttributes attrib;
XGetWindowAttributes(data->videodata->display, w, &attrib);
window->x = attrib.x;
window->y = attrib.y;
window->w = attrib.width;
window->h = attrib.height;
if (attrib.map_state != IsUnmapped) {
window->flags |= SDL_WINDOW_SHOWN;
} else {
window->flags &= ~SDL_WINDOW_SHOWN;
}
178
data->visual = attrib.visual;
179
data->colormap = attrib.colormap;
180
}
181
182
{
183
184
185
186
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;
187
188
189
190
191
192
193
Atom actualType;
int actualFormat;
unsigned long i, numItems, bytesAfter;
unsigned char *propertyValue = NULL;
long maxLength = 1024;
if (XGetWindowProperty(data->videodata->display, w, _NET_WM_STATE,
194
195
196
197
0l, maxLength, False, XA_ATOM, &actualType,
&actualFormat, &numItems, &bytesAfter,
&propertyValue) == Success) {
Atom *atoms = (Atom *) propertyValue;
198
int maximized = 0;
199
int fullscreen = 0;
200
201
202
203
204
205
for (i = 0; i < numItems; ++i) {
if (atoms[i] == _NET_WM_STATE_MAXIMIZED_VERT) {
maximized |= 1;
} else if (atoms[i] == _NET_WM_STATE_MAXIMIZED_HORZ) {
maximized |= 2;
206
207
} else if ( atoms[i] == _NET_WM_STATE_FULLSCREEN) {
fullscreen = 1;
208
209
210
211
}
}
if (maximized == 3) {
window->flags |= SDL_WINDOW_MAXIMIZED;
212
213
} else if (fullscreen == 1) {
window->flags |= SDL_WINDOW_FULLSCREEN;
214
215
216
217
218
}
XFree(propertyValue);
}
}
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
/* FIXME: How can I tell?
{
DWORD style = GetWindowLong(hwnd, GWL_STYLE);
if (style & WS_VISIBLE) {
if (style & (WS_BORDER | WS_THICKFRAME)) {
window->flags &= ~SDL_WINDOW_BORDERLESS;
} else {
window->flags |= SDL_WINDOW_BORDERLESS;
}
if (style & WS_THICKFRAME) {
window->flags |= SDL_WINDOW_RESIZABLE;
} else {
window->flags &= ~SDL_WINDOW_RESIZABLE;
}
if (style & WS_MINIMIZE) {
window->flags |= SDL_WINDOW_MINIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MINIMIZED;
}
}
if (GetFocus() == hwnd) {
int index = data->videodata->keyboard;
window->flags |= SDL_WINDOW_INPUT_FOCUS;
242
SDL_SetKeyboardFocus(index, data->window);
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
RECT rect;
GetClientRect(hwnd, &rect);
ClientToScreen(hwnd, (LPPOINT) & rect);
ClientToScreen(hwnd, (LPPOINT) & rect + 1);
ClipCursor(&rect);
}
}
*/
/* All done! */
window->driverdata = data;
return 0;
}
int
X11_CreateWindow(_THIS, SDL_Window * window)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
SDL_DisplayData *displaydata =
264
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
265
266
Display *display = data->display;
int screen = displaydata->screen;
267
268
269
270
271
272
273
Visual *visual;
int depth;
XSetWindowAttributes xattr;
Window w;
XSizeHints *sizehints;
XWMHints *wmhints;
XClassHint *classhints;
274
275
Atom _NET_WM_WINDOW_TYPE;
Atom _NET_WM_WINDOW_TYPE_NORMAL;
276
277
int wmstate_count;
Atom wmstate_atoms[3];
278
279
280
281
282
283
284
285
286
#if SDL_VIDEO_DRIVER_X11_XINERAMA
/* FIXME
if ( use_xinerama ) {
x = xinerama_info.x_org;
y = xinerama_info.y_org;
}
*/
#endif
287
#if SDL_VIDEO_OPENGL_GLX
288
if (window->flags & SDL_WINDOW_OPENGL) {
289
290
XVisualInfo *vinfo;
291
vinfo = X11_GL_GetVisual(_this, display, screen);
292
293
294
295
296
297
298
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
299
300
301
302
303
#endif
#ifdef SDL_VIDEO_DRIVER_PANDORA
if (window->flags & SDL_WINDOW_OPENGL) {
XVisualInfo *vinfo;
304
vinfo = X11_GLES_GetVisual(_this, display, screen);
305
306
307
308
309
310
311
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
312
313
#endif
{
314
315
316
317
visual = displaydata->visual;
depth = displaydata->depth;
}
318
xattr.override_redirect = False;
319
320
xattr.background_pixel = 0;
xattr.border_pixel = 0;
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
if (visual->class == DirectColor) {
Status status;
XColor *colorcells;
int i;
int ncolors;
int rmax, gmax, bmax;
int rmask, gmask, bmask;
int rshift, gshift, bshift;
xattr.colormap =
XCreateColormap(display, RootWindow(display, screen),
visual, AllocAll);
/* If we can't create a colormap, then we must die */
if (!xattr.colormap) {
SDL_SetError("Could not create writable colormap");
return -1;
}
/* OK, we got a colormap, now fill it in as best as we can */
colorcells = SDL_malloc(visual->map_entries * sizeof(XColor));
if (!colorcells) {
SDL_OutOfMemory();
return -1;
}
ncolors = visual->map_entries;
rmax = 0xffff;
gmax = 0xffff;
bmax = 0xffff;
rshift = 0;
rmask = visual->red_mask;
while (0 == (rmask & 1)) {
rshift++;
rmask >>= 1;
}
gshift = 0;
gmask = visual->green_mask;
while (0 == (gmask & 1)) {
gshift++;
gmask >>= 1;
}
bshift = 0;
bmask = visual->blue_mask;
while (0 == (bmask & 1)) {
bshift++;
bmask >>= 1;
}
/* build the color table pixel values */
for (i = 0; i < ncolors; i++) {
Uint32 red = (rmax * i) / (ncolors - 1);
Uint32 green = (gmax * i) / (ncolors - 1);
Uint32 blue = (bmax * i) / (ncolors - 1);
Uint32 rbits = (rmask * i) / (ncolors - 1);
Uint32 gbits = (gmask * i) / (ncolors - 1);
Uint32 bbits = (bmask * i) / (ncolors - 1);
Uint32 pix =
(rbits << rshift) | (gbits << gshift) | (bbits << bshift);
colorcells[i].pixel = pix;
colorcells[i].red = red;
colorcells[i].green = green;
colorcells[i].blue = blue;
colorcells[i].flags = DoRed | DoGreen | DoBlue;
}
XStoreColors(display, xattr.colormap, colorcells, ncolors);
SDL_free(colorcells);
} else {
xattr.colormap =
XCreateColormap(display, RootWindow(display, screen),
visual, AllocNone);
}
403
404
405
406
w = XCreateWindow(display, RootWindow(display, screen),
window->x, window->y, window->w, window->h,
0, depth, InputOutput, visual,
407
408
(CWOverrideRedirect | CWBackPixel | CWBorderPixel |
CWColormap), &xattr);
409
410
411
412
if (!w) {
SDL_SetError("Couldn't create window");
return -1;
}
413
414
415
416
417
418
419
420
421
422
423
424
425
#if SDL_VIDEO_DRIVER_PANDORA
/* Create the GLES window surface */
_this->gles_data->egl_surface =
_this->gles_data->eglCreateWindowSurface(_this->gles_data->
egl_display,
_this->gles_data->egl_config,
(NativeWindowType) w, NULL);
if (_this->gles_data->egl_surface == EGL_NO_SURFACE) {
SDL_SetError("Could not create GLES window surface");
return -1;
}
#endif
426
427
428
sizehints = XAllocSizeHints();
if (sizehints) {
429
if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
430
431
sizehints->min_width = sizehints->max_width = window->w;
sizehints->min_height = sizehints->max_height = window->h;
432
sizehints->flags = PMaxSize | PMinSize;
433
}
434
435
436
sizehints->x = window->x;
sizehints->y = window->y;
sizehints->flags |= USPosition;
437
XSetWMNormalHints(display, w, sizehints);
438
439
440
XFree(sizehints);
}
441
if (window->flags & SDL_WINDOW_BORDERLESS) {
442
443
444
445
446
447
448
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to set MWM hints */
449
WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True);
450
451
452
453
454
455
456
457
458
459
460
461
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};
462
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
463
PropModeReplace, (unsigned char *) &MWMHints,
464
sizeof(MWMHints) / 4);
465
466
467
set = SDL_TRUE;
}
/* Now try to set KWM hints */
468
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
469
470
471
if (WM_HINTS != None) {
long KWMHints = 0;
472
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
473
474
PropModeReplace,
(unsigned char *) &KWMHints,
475
sizeof(KWMHints) / 4);
476
477
478
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
479
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
480
481
482
if (WM_HINTS != None) {
long GNOMEHints = 0;
483
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
484
485
PropModeReplace,
(unsigned char *) &GNOMEHints,
486
sizeof(GNOMEHints) / 4);
487
488
489
490
set = SDL_TRUE;
}
/* Finally set the transient hints if necessary */
if (!set) {
491
XSetTransientForHint(display, w, RootWindow(display, screen));
492
493
494
495
496
497
498
499
500
}
} 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 */
501
WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True);
502
if (WM_HINTS != None) {
503
XDeleteProperty(display, w, WM_HINTS);
504
505
506
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
507
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
508
if (WM_HINTS != None) {
509
XDeleteProperty(display, w, WM_HINTS);
510
511
512
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
513
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
514
if (WM_HINTS != None) {
515
XDeleteProperty(display, w, WM_HINTS);
516
517
518
519
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if (!set) {
520
XDeleteProperty(display, w, XA_WM_TRANSIENT_FOR);
521
522
523
524
525
526
527
}
}
/* Set the input hints so we get keyboard input */
wmhints = XAllocWMHints();
if (wmhints) {
wmhints->input = True;
528
wmhints->flags = InputHint;
529
XSetWMHints(display, w, wmhints);
530
531
532
533
534
535
536
537
XFree(wmhints);
}
/* Set the class hints so we can get an icon (AfterStep) */
classhints = XAllocClassHint();
if (classhints != NULL) {
classhints->res_name = data->classname;
classhints->res_class = data->classname;
538
XSetClassHint(display, w, classhints);
539
540
541
XFree(classhints);
}
542
543
544
545
546
547
548
549
/* Set the window manager state */
wmstate_count = X11_GetWMStateProperty(_this, window, wmstate_atoms);
if (wmstate_count > 0) {
XChangeProperty(display, w, data->_NET_WM_STATE, XA_ATOM, 32,
PropModeReplace,
(unsigned char *)wmstate_atoms, wmstate_count);
} else {
XDeleteProperty(display, w, data->_NET_WM_STATE);
550
551
}
552
553
554
555
556
557
558
/* Let the window manager know we're a "normal" window */
_NET_WM_WINDOW_TYPE = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
_NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(display, "_NET_WM_WINDOW_TYPE_NORMAL", False);
XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32,
PropModeReplace,
(unsigned char *)&_NET_WM_WINDOW_TYPE_NORMAL, 1);
559
/* Allow the window to be deleted by the window manager */
560
XSetWMProtocols(display, w, &data->WM_DELETE_WINDOW, 1);
561
562
if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) {
563
XDestroyWindow(display, w);
564
565
return -1;
}
566
567
568
569
570
571
#ifdef X_HAVE_UTF8_STRING
{
Uint32 fevent = 0;
pXGetICValues(((SDL_WindowData *) window->driverdata)->ic,
XNFilterEvents, &fevent, NULL);
572
XSelectInput(display, w,
573
574
575
576
577
578
579
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask | fevent));
}
#else
580
{
581
XSelectInput(display, w,
582
583
584
585
586
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask));
587
}
588
589
#endif
590
591
XFlush(display);
592
593
594
595
return 0;
}
int
596
X11_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
597
598
599
{
Window w = (Window) data;
600
window->title = X11_GetWindowTitle(_this, w);
601
602
603
604
605
606
607
if (SetupWindowData(_this, window, w, SDL_FALSE) < 0) {
return -1;
}
return 0;
}
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
char *
X11_GetWindowTitle(_THIS, Window xwindow)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
Display *display = data->display;
int status, real_format;
Atom real_type;
unsigned long items_read, items_left;
unsigned char *propdata;
char *title = NULL;
status = XGetWindowProperty(display, xwindow, data->_NET_WM_NAME,
0L, 8192L, False, data->UTF8_STRING, &real_type, &real_format,
&items_read, &items_left, &propdata);
if (status == Success) {
title = SDL_strdup(SDL_static_cast(char*, propdata));
XFree(propdata);
} else {
status = XGetWindowProperty(display, xwindow, XA_WM_NAME,
0L, 8192L, False, XA_STRING, &real_type, &real_format,
&items_read, &items_left, &propdata);
if (status == Success) {
title = SDL_iconv_string("UTF-8", "", SDL_static_cast(char*, propdata), items_read+1);
} else {
title = SDL_strdup("");
}
}
return title;
}
638
639
640
641
642
643
644
645
646
647
648
void
X11_SetWindowTitle(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
XTextProperty titleprop, iconprop;
Status status;
const char *title = window->title;
const char *icon = NULL;
#ifdef X_HAVE_UTF8_STRING
649
650
Atom _NET_WM_NAME = data->videodata->_NET_WM_NAME;
Atom _NET_WM_ICON_NAME = data->videodata->_NET_WM_ICON_NAME;
651
652
653
#endif
if (title != NULL) {
654
655
char *title_locale = SDL_iconv_utf8_locale(title);
if (!title_locale) {
656
657
658
SDL_OutOfMemory();
return;
}
659
660
status = XStringListToTextProperty(&title_locale, 1, &titleprop);
SDL_free(title_locale);
661
if (status) {
662
XSetTextProperty(display, data->xwindow, &titleprop, XA_WM_NAME);
663
664
665
666
667
668
669
670
XFree(titleprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status =
Xutf8TextListToTextProperty(display, (char **) &title, 1,
XUTF8StringStyle, &titleprop);
if (status == Success) {
671
XSetTextProperty(display, data->xwindow, &titleprop,
672
673
674
675
676
677
678
_NET_WM_NAME);
XFree(titleprop.value);
}
}
#endif
}
if (icon != NULL) {
679
680
char *icon_locale = SDL_iconv_utf8_locale(icon);
if (!icon_locale) {
681
682
683
SDL_OutOfMemory();
return;
}
684
685
status = XStringListToTextProperty(&icon_locale, 1, &iconprop);
SDL_free(icon_locale);
686
if (status) {
687
XSetTextProperty(display, data->xwindow, &iconprop,
688
689
690
691
692
693
694
695
696
XA_WM_ICON_NAME);
XFree(iconprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status =
Xutf8TextListToTextProperty(display, (char **) &icon, 1,
XUTF8StringStyle, &iconprop);
if (status == Success) {
697
XSetTextProperty(display, data->xwindow, &iconprop,
698
699
700
701
702
703
_NET_WM_ICON_NAME);
XFree(iconprop.value);
}
}
#endif
}
704
XFlush(display);
705
706
}
707
708
709
710
711
void
X11_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
712
Atom _NET_WM_ICON = data->videodata->_NET_WM_ICON;
713
714
715
716
717
if (icon) {
SDL_PixelFormat format;
SDL_Surface *surface;
int propsize;
718
long *propdata;
719
720
/* Convert the icon to ARGB for modern window managers */
721
SDL_InitFormat(&format, SDL_PIXELFORMAT_ARGB8888);
722
723
724
725
726
727
surface = SDL_ConvertSurface(icon, &format, 0);
if (!surface) {
return;
}
/* Set the _NET_WM_ICON property */
728
propsize = 2 + (icon->w * icon->h);
729
propdata = SDL_malloc(propsize * sizeof(long));
730
if (propdata) {
731
732
733
734
int x, y;
Uint32 *src;
long *dst;
735
736
propdata[0] = icon->w;
propdata[1] = icon->h;
737
738
739
740
741
742
743
dst = &propdata[2];
for (y = 0; y < icon->h; ++y) {
src = (Uint32*)((Uint8*)surface->pixels + y * surface->pitch);
for (x = 0; x < icon->w; ++x) {
*dst++ = *src++;
}
}
744
XChangeProperty(display, data->xwindow, _NET_WM_ICON, XA_CARDINAL,
745
746
32, PropModeReplace, (unsigned char *) propdata,
propsize);
747
748
749
}
SDL_FreeSurface(surface);
} else {
750
XDeleteProperty(display, data->xwindow, _NET_WM_ICON);
751
}
752
XFlush(display);
753
754
}
755
756
757
758
759
void
X11_SetWindowPosition(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
760
int x, y;
761
762
XMoveWindow(display, data->xwindow, window->x, window->y);
763
XFlush(display);
764
765
766
767
768
769
770
771
}
void
X11_SetWindowSize(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
772
if (SDL_IsShapedWindow(window))
773
X11_ResizeWindowShape(window);
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
/* Apparently, if the X11 Window is set to a 'non-resizable' window, you cannot resize it using the XResizeWindow, thus
we must set the size hints to adjust the window size.*/
XSizeHints *sizehints = XAllocSizeHints();
long userhints;
XGetWMNormalHints(display, data->xwindow, sizehints, &userhints);
sizehints->min_width = sizehints->max_height = window->w;
sizehints->min_height = sizehints->max_height = window->h;
XSetWMNormalHints(display, data->xwindow, sizehints);
XFree(sizehints);
} else
XResizeWindow(display, data->xwindow, window->w, window->h);
790
XFlush(display);
791
792
793
794
795
796
797
798
}
void
X11_ShowWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
799
XMapRaised(display, data->xwindow);
800
XFlush(display);
801
802
803
804
805
806
807
808
}
void
X11_HideWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
809
XUnmapWindow(display, data->xwindow);
810
XFlush(display);
811
812
813
814
815
816
817
818
}
void
X11_RaiseWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
819
XRaiseWindow(display, data->xwindow);
820
XFlush(display);
821
822
}
823
static void
824
SetWindowMaximized(_THIS, SDL_Window * window, SDL_bool maximized)
825
826
827
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_DisplayData *displaydata =
828
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
829
Display *display = data->videodata->display;
830
831
832
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
833
834
835
836
837
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
838
SDL_zero(e);
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
e.xany.type = ClientMessage;
e.xclient.message_type = _NET_WM_STATE;
e.xclient.format = 32;
e.xclient.window = data->xwindow;
e.xclient.data.l[0] =
maximized ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
e.xclient.data.l[1] = _NET_WM_STATE_MAXIMIZED_VERT;
e.xclient.data.l[2] = _NET_WM_STATE_MAXIMIZED_HORZ;
e.xclient.data.l[3] = 0l;
XSendEvent(display, RootWindow(display, displaydata->screen), 0,
SubstructureNotifyMask | SubstructureRedirectMask, &e);
} else {
int count = 0;
Atom atoms[3];
if (window->flags & SDL_WINDOW_FULLSCREEN) {
atoms[count++] = _NET_WM_STATE_FULLSCREEN;
}
if (maximized) {
atoms[count++] = _NET_WM_STATE_MAXIMIZED_VERT;
atoms[count++] = _NET_WM_STATE_MAXIMIZED_HORZ;
}
if (count > 0) {
XChangeProperty(display, data->xwindow, _NET_WM_STATE, XA_ATOM, 32,
PropModeReplace, (unsigned char *)atoms, count);
} else {
XDeleteProperty(display, data->xwindow, _NET_WM_STATE);
}
}
869
XFlush(display);
870
871
}
872
873
874
void
X11_MaximizeWindow(_THIS, SDL_Window * window)
{
875
SetWindowMaximized(_this, window, SDL_TRUE);
876
877
878
879
880
}
void
X11_MinimizeWindow(_THIS, SDL_Window * window)
{
881
882
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_DisplayData *displaydata =
883
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
884
885
886
Display *display = data->videodata->display;
XIconifyWindow(display, data->xwindow, displaydata->screen);
887
XFlush(display);
888
889
890
891
892
}
void
X11_RestoreWindow(_THIS, SDL_Window * window)
{
893
SetWindowMaximized(_this, window, SDL_FALSE);
894
895
896
X11_ShowWindow(_this, window);
}
897
898
void
X11_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * _display, SDL_bool fullscreen)
899
900
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
901
SDL_DisplayData *displaydata = (SDL_DisplayData *) _display->driverdata;
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
Display *display = data->videodata->display;
Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT = data->videodata->_NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ = data->videodata->_NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
SDL_zero(e);
e.xany.type = ClientMessage;
e.xclient.message_type = _NET_WM_STATE;
e.xclient.format = 32;
e.xclient.window = data->xwindow;
e.xclient.data.l[0] =
fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
e.xclient.data.l[1] = _NET_WM_STATE_FULLSCREEN;
e.xclient.data.l[3] = 0l;
XSendEvent(display, RootWindow(display, displaydata->screen), 0,
SubstructureNotifyMask | SubstructureRedirectMask, &e);
} else {
int count = 0;
Atom atoms[3];
if (fullscreen) {
atoms[count++] = _NET_WM_STATE_FULLSCREEN;
}
if (window->flags & SDL_WINDOW_MAXIMIZED) {
atoms[count++] = _NET_WM_STATE_MAXIMIZED_VERT;
atoms[count++] = _NET_WM_STATE_MAXIMIZED_HORZ;
}
if (count > 0) {
XChangeProperty(display, data->xwindow, _NET_WM_STATE, XA_ATOM, 32,
PropModeReplace, (unsigned char *)atoms, count);
} else {
XDeleteProperty(display, data->xwindow, _NET_WM_STATE);
}
}
XFlush(display);
}
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
int
X11_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
Visual *visual = data->visual;
Colormap colormap = data->colormap;
XColor *colorcells;
int ncolors;
int rmask, gmask, bmask;
int rshift, gshift, bshift;
int i, j;
if (visual->class != DirectColor) {
SDL_SetError("Window doesn't have DirectColor visual");
return -1;
}
ncolors = visual->map_entries;
colorcells = SDL_malloc(ncolors * sizeof(XColor));
if (!colorcells) {
SDL_OutOfMemory();
return -1;
}
rshift = 0;
rmask = visual->red_mask;
while (0 == (rmask & 1)) {
rshift++;
rmask >>= 1;
}
gshift = 0;
gmask = visual->green_mask;
while (0 == (gmask & 1)) {
gshift++;
gmask >>= 1;
}
bshift = 0;
bmask = visual->blue_mask;
while (0 == (bmask & 1)) {
bshift++;
bmask >>= 1;
}
/* build the color table pixel values */
for (i = 0; i < ncolors; i++) {
Uint32 rbits = (rmask * i) / (ncolors - 1);
Uint32 gbits = (gmask * i) / (ncolors - 1);
Uint32 bbits = (bmask * i) / (ncolors - 1);
Uint32 pix = (rbits << rshift) | (gbits << gshift) | (bbits << bshift);
colorcells[i].pixel = pix;
colorcells[i].red = ramp[(0 * 256) + i];
colorcells[i].green = ramp[(1 * 256) + i];