This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_x11window.c
954 lines (851 loc) · 30.3 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2011 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
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
Lesser General Public License for more details.
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
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "../SDL_sysvideo.h"
25
#include "../SDL_pixels_c.h"
26
#include "../../events/SDL_keyboard_c.h"
27
#include "../../events/SDL_mouse_c.h"
28
29
#include "SDL_x11video.h"
30
#include "SDL_x11mouse.h"
31
#include "SDL_x11shape.h"
32
33
34
35
36
#ifdef SDL_VIDEO_DRIVER_PANDORA
#include "SDL_x11opengles.h"
#endif
37
#include "SDL_timer.h"
38
39
#include "SDL_syswm.h"
40
41
42
43
#define _NET_WM_STATE_REMOVE 0l
#define _NET_WM_STATE_ADD 1l
#define _NET_WM_STATE_TOGGLE 2l
44
static SDL_bool
45
X11_IsWindowOldFullscreen(_THIS, SDL_Window * window)
46
{
47
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
48
49
50
51
52
53
54
55
56
/* 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;
}
}
57
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
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;
}
88
89
90
91
92
static void
X11_GetDisplaySize(_THIS, SDL_Window * window, int *w, int *h)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
SDL_DisplayData *displaydata =
93
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
94
95
XWindowAttributes attr;
96
97
98
99
100
101
102
103
104
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;
}
}
105
106
107
108
109
110
111
112
if (w) {
*w = attr.width;
}
if (h) {
*h = attr.height;
}
}
113
114
115
116
117
118
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;
119
int windowlistlength = videodata->windowlistlength;
120
121
122
SDL_WindowData **windowlist = videodata->windowlist;
/* Allocate the window data */
123
data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));
124
125
126
127
if (!data) {
SDL_OutOfMemory();
return -1;
}
128
129
data->window = window;
data->xwindow = w;
130
131
132
133
134
135
136
137
138
139
140
141
#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;
142
143
/* Associate the data with the window */
144
145
146
if (numwindows < windowlistlength) {
windowlist[numwindows] = data;
videodata->numwindows++;
147
} else {
148
149
150
151
152
153
154
155
156
157
158
159
160
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;
161
162
}
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/* 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;
}
177
data->visual = attrib.visual;
178
}
179
180
{
181
182
183
184
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;
185
186
187
188
189
190
191
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,
192
193
194
195
0l, maxLength, False, XA_ATOM, &actualType,
&actualFormat, &numItems, &bytesAfter,
&propertyValue) == Success) {
Atom *atoms = (Atom *) propertyValue;
196
int maximized = 0;
197
int fullscreen = 0;
198
199
200
201
202
203
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;
204
205
} else if ( atoms[i] == _NET_WM_STATE_FULLSCREEN) {
fullscreen = 1;
206
207
208
209
}
}
if (maximized == 3) {
window->flags |= SDL_WINDOW_MAXIMIZED;
210
211
} else if (fullscreen == 1) {
window->flags |= SDL_WINDOW_FULLSCREEN;
212
213
214
215
216
}
XFree(propertyValue);
}
}
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
/* 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;
240
SDL_SetKeyboardFocus(index, data->window);
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
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 =
262
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
263
264
Display *display = data->display;
int screen = displaydata->screen;
265
266
267
268
269
270
271
Visual *visual;
int depth;
XSetWindowAttributes xattr;
Window w;
XSizeHints *sizehints;
XWMHints *wmhints;
XClassHint *classhints;
272
273
Atom _NET_WM_WINDOW_TYPE;
Atom _NET_WM_WINDOW_TYPE_NORMAL;
274
275
int wmstate_count;
Atom wmstate_atoms[3];
276
277
278
279
280
281
282
283
284
#if SDL_VIDEO_DRIVER_X11_XINERAMA
/* FIXME
if ( use_xinerama ) {
x = xinerama_info.x_org;
y = xinerama_info.y_org;
}
*/
#endif
285
#if SDL_VIDEO_OPENGL_GLX
286
if (window->flags & SDL_WINDOW_OPENGL) {
287
288
XVisualInfo *vinfo;
289
vinfo = X11_GL_GetVisual(_this, display, screen);
290
291
292
293
294
295
296
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
297
298
299
300
301
#endif
#ifdef SDL_VIDEO_DRIVER_PANDORA
if (window->flags & SDL_WINDOW_OPENGL) {
XVisualInfo *vinfo;
302
vinfo = X11_GLES_GetVisual(_this, display, screen);
303
304
305
306
307
308
309
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
310
311
#endif
{
312
313
314
315
visual = displaydata->visual;
depth = displaydata->depth;
}
316
xattr.override_redirect = False;
317
318
xattr.background_pixel = 0;
xattr.border_pixel = 0;
319
xattr.colormap = XCreateColormap(display, RootWindow(display, screen), visual, AllocNone);
320
321
322
323
w = XCreateWindow(display, RootWindow(display, screen),
window->x, window->y, window->w, window->h,
0, depth, InputOutput, visual,
324
325
(CWOverrideRedirect | CWBackPixel | CWBorderPixel |
CWColormap), &xattr);
326
327
328
329
if (!w) {
SDL_SetError("Couldn't create window");
return -1;
}
330
331
332
333
334
335
336
337
338
339
340
341
342
#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
343
344
345
sizehints = XAllocSizeHints();
if (sizehints) {
346
if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
347
348
sizehints->min_width = sizehints->max_width = window->w;
sizehints->min_height = sizehints->max_height = window->h;
349
sizehints->flags = PMaxSize | PMinSize;
350
}
351
352
353
sizehints->x = window->x;
sizehints->y = window->y;
sizehints->flags |= USPosition;
354
XSetWMNormalHints(display, w, sizehints);
355
356
357
XFree(sizehints);
}
358
if (window->flags & SDL_WINDOW_BORDERLESS) {
359
360
361
362
363
364
365
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to set MWM hints */
366
WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True);
367
368
369
370
371
372
373
374
375
376
377
378
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};
379
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
380
PropModeReplace, (unsigned char *) &MWMHints,
381
sizeof(MWMHints) / 4);
382
383
384
set = SDL_TRUE;
}
/* Now try to set KWM hints */
385
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
386
387
388
if (WM_HINTS != None) {
long KWMHints = 0;
389
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
390
391
PropModeReplace,
(unsigned char *) &KWMHints,
392
sizeof(KWMHints) / 4);
393
394
395
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
396
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
397
398
399
if (WM_HINTS != None) {
long GNOMEHints = 0;
400
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
401
402
PropModeReplace,
(unsigned char *) &GNOMEHints,
403
sizeof(GNOMEHints) / 4);
404
405
406
407
set = SDL_TRUE;
}
/* Finally set the transient hints if necessary */
if (!set) {
408
XSetTransientForHint(display, w, RootWindow(display, screen));
409
410
411
412
413
414
415
416
417
}
} 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 */
418
WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True);
419
if (WM_HINTS != None) {
420
XDeleteProperty(display, w, WM_HINTS);
421
422
423
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
424
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
425
if (WM_HINTS != None) {
426
XDeleteProperty(display, w, WM_HINTS);
427
428
429
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
430
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
431
if (WM_HINTS != None) {
432
XDeleteProperty(display, w, WM_HINTS);
433
434
435
436
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if (!set) {
437
XDeleteProperty(display, w, XA_WM_TRANSIENT_FOR);
438
439
440
441
442
443
444
}
}
/* Set the input hints so we get keyboard input */
wmhints = XAllocWMHints();
if (wmhints) {
wmhints->input = True;
445
wmhints->flags = InputHint;
446
XSetWMHints(display, w, wmhints);
447
448
449
450
451
452
453
454
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;
455
XSetClassHint(display, w, classhints);
456
457
458
XFree(classhints);
}
459
460
461
462
463
464
465
466
/* 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);
467
468
}
469
470
471
472
473
474
475
/* 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);
476
/* Allow the window to be deleted by the window manager */
477
XSetWMProtocols(display, w, &data->WM_DELETE_WINDOW, 1);
478
479
if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) {
480
XDestroyWindow(display, w);
481
482
return -1;
}
483
484
485
486
487
488
#ifdef X_HAVE_UTF8_STRING
{
Uint32 fevent = 0;
pXGetICValues(((SDL_WindowData *) window->driverdata)->ic,
XNFilterEvents, &fevent, NULL);
489
XSelectInput(display, w,
490
491
492
493
494
495
496
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask | fevent));
}
#else
497
{
498
XSelectInput(display, w,
499
500
501
502
503
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask));
504
}
505
506
#endif
507
508
XFlush(display);
509
510
511
512
return 0;
}
int
513
X11_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
514
515
516
{
Window w = (Window) data;
517
window->title = X11_GetWindowTitle(_this, w);
518
519
520
521
522
523
524
if (SetupWindowData(_this, window, w, SDL_FALSE) < 0) {
return -1;
}
return 0;
}
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
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;
}
555
556
557
558
559
560
561
562
563
564
565
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
566
567
Atom _NET_WM_NAME = data->videodata->_NET_WM_NAME;
Atom _NET_WM_ICON_NAME = data->videodata->_NET_WM_ICON_NAME;
568
569
570
#endif
if (title != NULL) {
571
572
char *title_locale = SDL_iconv_utf8_locale(title);
if (!title_locale) {
573
574
575
SDL_OutOfMemory();
return;
}
576
577
status = XStringListToTextProperty(&title_locale, 1, &titleprop);
SDL_free(title_locale);
578
if (status) {
579
XSetTextProperty(display, data->xwindow, &titleprop, XA_WM_NAME);
580
581
582
583
584
585
586
587
XFree(titleprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status =
Xutf8TextListToTextProperty(display, (char **) &title, 1,
XUTF8StringStyle, &titleprop);
if (status == Success) {
588
XSetTextProperty(display, data->xwindow, &titleprop,
589
590
591
592
593
594
595
_NET_WM_NAME);
XFree(titleprop.value);
}
}
#endif
}
if (icon != NULL) {
596
597
char *icon_locale = SDL_iconv_utf8_locale(icon);
if (!icon_locale) {
598
599
600
SDL_OutOfMemory();
return;
}
601
602
status = XStringListToTextProperty(&icon_locale, 1, &iconprop);
SDL_free(icon_locale);
603
if (status) {
604
XSetTextProperty(display, data->xwindow, &iconprop,
605
606
607
608
609
610
611
612
613
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) {
614
XSetTextProperty(display, data->xwindow, &iconprop,
615
616
617
618
619
620
_NET_WM_ICON_NAME);
XFree(iconprop.value);
}
}
#endif
}
621
XFlush(display);
622
623
}
624
625
626
627
628
void
X11_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
629
Atom _NET_WM_ICON = data->videodata->_NET_WM_ICON;
630
631
632
633
634
if (icon) {
SDL_PixelFormat format;
SDL_Surface *surface;
int propsize;
635
long *propdata;
636
637
/* Convert the icon to ARGB for modern window managers */
638
SDL_InitFormat(&format, SDL_PIXELFORMAT_ARGB8888);
639
640
641
642
643
644
surface = SDL_ConvertSurface(icon, &format, 0);
if (!surface) {
return;
}
/* Set the _NET_WM_ICON property */
645
propsize = 2 + (icon->w * icon->h);
646
propdata = SDL_malloc(propsize * sizeof(long));
647
if (propdata) {
648
649
650
651
int x, y;
Uint32 *src;
long *dst;
652
653
propdata[0] = icon->w;
propdata[1] = icon->h;
654
655
656
657
658
659
660
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++;
}
}
661
XChangeProperty(display, data->xwindow, _NET_WM_ICON, XA_CARDINAL,
662
663
32, PropModeReplace, (unsigned char *) propdata,
propsize);
664
665
666
}
SDL_FreeSurface(surface);
} else {
667
XDeleteProperty(display, data->xwindow, _NET_WM_ICON);
668
}
669
XFlush(display);
670
671
}
672
673
674
675
676
void
X11_SetWindowPosition(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
677
SDL_bool oldstyle_fullscreen;
678
int x, y;
679
680
/* ICCCM2.0-compliant window managers can handle fullscreen windows */
681
oldstyle_fullscreen = X11_IsWindowOldFullscreen(_this, window);
682
683
if (oldstyle_fullscreen
684
|| SDL_WINDOWPOS_ISCENTERED(window->x)) {
685
686
X11_GetDisplaySize(_this, window, &x, NULL);
x = (x - window->w) / 2;
687
688
689
} else {
x = window->x;
}
690
if (oldstyle_fullscreen
691
|| SDL_WINDOWPOS_ISCENTERED(window->y)) {
692
693
X11_GetDisplaySize(_this, window, NULL, &y);
y = (y - window->h) / 2;
694
695
696
} else {
y = window->y;
}
697
XMoveWindow(display, data->xwindow, x, y);
698
XFlush(display);
699
700
701
702
703
704
705
706
}
void
X11_SetWindowSize(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
707
if (SDL_IsShapedWindow(window))
708
X11_ResizeWindowShape(window);
709
XResizeWindow(display, data->xwindow, window->w, window->h);
710
XFlush(display);
711
712
713
714
715
716
717
718
}
void
X11_ShowWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
719
XMapRaised(display, data->xwindow);
720
XFlush(display);
721
722
723
724
725
726
727
728
}
void
X11_HideWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
729
XUnmapWindow(display, data->xwindow);
730
XFlush(display);
731
732
733
734
735
736
737
738
}
void
X11_RaiseWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
739
XRaiseWindow(display, data->xwindow);
740
XFlush(display);
741
742
}
743
static void
744
SetWindowMaximized(_THIS, SDL_Window * window, SDL_bool maximized)
745
746
747
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_DisplayData *displaydata =
748
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
749
Display *display = data->videodata->display;
750
751
752
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;
753
754
755
756
757
Atom _NET_WM_STATE_FULLSCREEN = data->videodata->_NET_WM_STATE_FULLSCREEN;
if (X11_IsWindowMapped(_this, window)) {
XEvent e;
758
SDL_zero(e);
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
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);
}
}
789
XFlush(display);
790
791
}
792
793
794
void
X11_MaximizeWindow(_THIS, SDL_Window * window)
{
795
SetWindowMaximized(_this, window, SDL_TRUE);
796
797
798
799
800
}
void
X11_MinimizeWindow(_THIS, SDL_Window * window)
{
801
802
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_DisplayData *displaydata =
803
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
804
805
806
Display *display = data->videodata->display;
XIconifyWindow(display, data->xwindow, displaydata->screen);
807
XFlush(display);
808
809
810
811
812
}
void
X11_RestoreWindow(_THIS, SDL_Window * window)
{
813
SetWindowMaximized(_this, window, SDL_FALSE);
814
815
816
X11_ShowWindow(_this, window);
}
817
818
void
X11_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * _display, SDL_bool fullscreen)
819
820
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
821
SDL_DisplayData *displaydata = (SDL_DisplayData *) _display->driverdata;
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
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
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);
}
864
865
866
void
X11_SetWindowGrab(_THIS, SDL_Window * window)
{
867
868
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
869
870
871
SDL_bool oldstyle_fullscreen;
/* ICCCM2.0-compliant window managers can handle fullscreen windows */
872
oldstyle_fullscreen = X11_IsWindowOldFullscreen(_this, window);
873
874
if (((window->flags & SDL_WINDOW_INPUT_GRABBED) || oldstyle_fullscreen)
875
&& (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
876
/* Try to grab the mouse */
877
878
for (;;) {
int result =
879
880
XGrabPointer(display, data->xwindow, True, 0, GrabModeAsync,
GrabModeAsync, data->xwindow, None, CurrentTime);
881
if (result == GrabSuccess) {
882
883
884
885
886
887
break;
}
SDL_Delay(100);
}
/* Raise the window if we grab the mouse */
888
XRaiseWindow(display, data->xwindow);
889
890
/* Now grab the keyboard */
891
XGrabKeyboard(display, data->xwindow, True, GrabModeAsync,
892
GrabModeAsync, CurrentTime);
893
894
895
896
} else {
XUngrabPointer(display, CurrentTime);
XUngrabKeyboard(display, CurrentTime);
}
897
898
899
900
901
902
}
void
X11_DestroyWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
903
window->driverdata = NULL;
904
905
if (data) {
906
907
908
909
910
911
912
SDL_VideoData *videodata = (SDL_VideoData *) data->videodata;
Display *display = videodata->display;
int numwindows = videodata->numwindows;
SDL_WindowData **windowlist = videodata->windowlist;
int i;
if (windowlist) {
913
for (i = 0; i < numwindows; ++i) {
914
if (windowlist[i] && (windowlist[i]->window == window)) {
915
916
917
918
919
windowlist[i] = windowlist[numwindows - 1];
windowlist[numwindows - 1] = NULL;
videodata->numwindows--;
break;
}
920
921
}
}
922
923
924
925
926
927
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XDestroyIC(data->ic);
}
#endif
if (data->created) {
928
XDestroyWindow(display, data->xwindow);
929
XFlush(display);
930
931
932
933
934
935
936
937
}
SDL_free(data);
}
}
SDL_bool
X11_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
{
938
939
940
941
942
943
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
if (info->version.major == SDL_MAJOR_VERSION &&
info->version.minor == SDL_MINOR_VERSION) {
info->subsystem = SDL_SYSWM_X11;
944
945
info->info.x11.display = display;
info->info.x11.window = data->xwindow;
946
947
948
949
950
951
952
953
954
return SDL_TRUE;
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return SDL_FALSE;
}
}
/* vi: set ts=4 sw=4 expandtab: */