pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial work on X11 window code in.

Browse source 
--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401997
This commit is contained in:
Sam Lantinga 2006-07-27 06:53:23 +00:00
parent 3ec5d40b87
commit cc0b655042
13 changed files with 1243 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/video/cocoa/SDL_cocoawindow.h
View file

@ -66,7 +66,7 @@ struct SDL_WindowData
{ {
SDL_WindowID windowID; SDL_WindowID windowID;
NSWindow *window; NSWindow *window;
BOOL created; SDL_bool created;
Cocoa_WindowListener *listener; Cocoa_WindowListener *listener;
struct SDL_VideoData *videodata; struct SDL_VideoData *videodata;
}; };

9
src/video/cocoa/SDL_cocoawindow.m
View file

@ -242,9 +242,10 @@ fprintf(stderr, "keyUp\n");
@end @end
static int static int
SetupWindowData(SDL_Window * window, NSWindow *nswindow, BOOL created) SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, SDL_bool created)
{ {
NSAutoreleasePool *pool; NSAutoreleasePool *pool;
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data; SDL_WindowData *data;
/* Allocate the window data */ /* Allocate the window data */
@ -256,7 +257,7 @@ SetupWindowData(SDL_Window * window, NSWindow *nswindow, BOOL created)
data->windowID = window->id; data->windowID = window->id;
data->window = nswindow; data->window = nswindow;
data->created = created; data->created = created;
data->videodata = (SDL_VideoData *) SDL_GetVideoDevice()->driverdata; data->videodata = videodata;
pool = [[NSAutoreleasePool alloc] init]; pool = [[NSAutoreleasePool alloc] init];
@ -380,7 +381,7 @@ Cocoa_CreateWindow(_THIS, SDL_Window * window)
[pool release]; [pool release];
if (SetupWindowData(window, nswindow, YES) < 0) { if (SetupWindowData(_this, window, nswindow, SDL_TRUE) < 0) {
[nswindow release]; [nswindow release];
return -1; return -1;
} }
@ -413,7 +414,7 @@ Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
[pool release]; [pool release];
return SetupWindowData(window, nswindow, NO); return SetupWindowData(_this, window, nswindow, SDL_FALSE);
} }
void void

25
src/video/win32/SDL_win32events.c
View file

@ -22,7 +22,6 @@
#include "SDL_config.h" #include "SDL_config.h"
#include "SDL_win32video.h" #include "SDL_win32video.h"
#include "SDL_version.h"
#include "SDL_syswm.h" #include "SDL_syswm.h"
#include "SDL_vkeys.h" #include "SDL_vkeys.h"
#include "../../events/SDL_events_c.h" #include "../../events/SDL_events_c.h"
@ -393,6 +392,18 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
SDL_WindowData *data; SDL_WindowData *data;
/* Send a SDL_SYSWMEVENT if the application wants them */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
SDL_SendSysWMEvent(&wmmsg);
}
/* Get the window data for the window */ /* Get the window data for the window */
data = (SDL_WindowData *) GetProp(hwnd, TEXT("SDL_WindowData")); data = (SDL_WindowData *) GetProp(hwnd, TEXT("SDL_WindowData"));
if (!data) { if (!data) {
@ -412,18 +423,6 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
} }
#endif #endif
/* Send a SDL_SYSWMEVENT if the application wants them */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
SDL_SendSysWMEvent(&wmmsg);
}
switch (msg) { switch (msg) {
case WM_SHOWWINDOW: case WM_SHOWWINDOW:

9
src/video/win32/SDL_win32window.c
View file

@ -31,8 +31,9 @@
static int static int
SetupWindowData(SDL_Window * window, HWND hwnd, BOOL created) SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created)
{ {
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data; SDL_WindowData *data;
/* Allocate the window data */ /* Allocate the window data */
@ -46,7 +47,7 @@ SetupWindowData(SDL_Window * window, HWND hwnd, BOOL created)
data->hdc = GetDC(hwnd); data->hdc = GetDC(hwnd);
data->created = created; data->created = created;
data->mouse_pressed = SDL_FALSE; data->mouse_pressed = SDL_FALSE;
data->videodata = (SDL_VideoData *) SDL_GetVideoDevice()->driverdata; data->videodata = videodata;
/* Associate the data with the window */ /* Associate the data with the window */
if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) { if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) {
@ -208,7 +209,7 @@ WIN_CreateWindow(_THIS, SDL_Window * window)
return -1; return -1;
} }
if (SetupWindowData(window, hwnd, TRUE) < 0) { if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
DestroyWindow(hwnd); DestroyWindow(hwnd);
return -1; return -1;
} }
@ -245,7 +246,7 @@ WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
SDL_stack_free(title); SDL_stack_free(title);
} }
if (SetupWindowData(window, hwnd, FALSE) < 0) { if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
return -1; return -1;
} }
return 0; return 0;

2
src/video/win32/SDL_win32window.h
View file

@ -30,7 +30,7 @@ typedef struct
HWND hwnd; HWND hwnd;
HDC hdc; HDC hdc;
WNDPROC wndproc; WNDPROC wndproc;
BOOL created; SDL_bool created;
int mouse_pressed; int mouse_pressed;
struct SDL_VideoData *videodata; struct SDL_VideoData *videodata;
} SDL_WindowData; } SDL_WindowData;

421
src/video/x11/SDL_x11events.c Normal file
View file

@ -0,0 +1,421 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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_syswm.h"
#include "SDL_x11video.h"
#include "../../events/SDL_events_c.h"
static void
X11_DispatchEvent(_THIS)
{
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data;
XEvent xevent;
int i;
SDL_zero(xevent); /* valgrind fix. --ryan. */
XNextEvent(videodata->display, &xevent);
/* Send a SDL_SYSWMEVENT if the application wants them */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
SDL_SendSysWMEvent(&wmmsg);
}
data = NULL;
for (i = 0; i < videodata->numwindows; ++i) {
if (videodata->windowlist[i]->window == xevent.xany.window) {
data = videodata->windowlist[i];
}
}
if (!data) {
return;
}
switch (xevent.type) {
/* Gaining mouse coverage? */
case EnterNotify:{
#ifdef DEBUG_XEVENTS
printf("EnterNotify! (%d,%d)\n", xevent.xcrossing.x,
xevent.xcrossing.y);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if ((xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab)) {
SDL_SetMouseFocus(videodata->mouse, data->windowID);
SDL_SendMouseMotion(videodata->mouse, 0, xevent.xcrossing.x,
xevent.xcrossing.y);
}
}
break;
/* Losing mouse coverage? */
case LeaveNotify:{
#ifdef DEBUG_XEVENTS
printf("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x,
xevent.xcrossing.y);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if ((xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab) &&
(xevent.xcrossing.detail != NotifyInferior)) {
SDL_SendMouseMotion(videodata->mouse, 0,
xevent.xcrossing.x, xevent.xcrossing.y);
SDL_SetMouseFocus(videodata->mouse, 0);
}
}
break;
/* Gaining input focus? */
case FocusIn:{
#ifdef DEBUG_XEVENTS
printf("FocusIn!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, data->windowID);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XSetICFocus(data->ic);
}
#endif
}
break;
/* Losing input focus? */
case FocusOut:{
#ifdef DEBUG_XEVENTS
printf("FocusOut!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, 0);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XUnsetICFocus(data->ic);
}
#endif
}
break;
/* Generated upon EnterWindow and FocusIn */
case KeymapNotify:{
#ifdef DEBUG_XEVENTS
printf("KeymapNotify!\n");
#endif
/* FIXME:
X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
*/
}
break;
/* Mouse motion? */
case MotionNotify:{
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y);
#endif
SDL_SendMouseMotion(videodata->mouse, 0, xevent.xmotion.x,
xevent.xmotion.y);
}
break;
/* Mouse button press? */
case ButtonPress:{
SDL_SendMouseButton(videodata->mouse, SDL_PRESSED,
xevent.xbutton.button);
}
break;
/* Mouse button release? */
case ButtonRelease:{
SDL_SendMouseButton(videodata->mouse, SDL_RELEASED,
xevent.xbutton.button);
}
break;
/* Key press? */
case KeyPress:{
#if 0 /* FIXME */
static SDL_keysym saved_keysym;
SDL_keysym keysym;
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
/* Get the translated SDL virtual keysym */
if (keycode) {
keysym.scancode = keycode;
keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
} else {
keysym = saved_keysym;
}
/* If we're not doing translation, we're done! */
if (!SDL_TranslateUNICODE) {
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
break;
}
if (XFilterEvent(&xevent, None)) {
if (xevent.xkey.keycode) {
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
} else {
/* Save event to be associated with IM text
In 1.3 we'll have a text event instead.. */
saved_keysym = keysym;
}
break;
}
/* Look up the translated value for the key event */
#ifdef X_HAVE_UTF8_STRING
if (data->ic != NULL) {
static Status state;
/* A UTF-8 character can be at most 6 bytes */
char keybuf[6];
if (Xutf8LookupString(data->ic, &xevent.xkey,
keybuf, sizeof(keybuf), NULL, &state)) {
keysym.unicode = Utf8ToUcs4((Uint8 *) keybuf);
}
} else
#endif
{
static XComposeStatus state;
char keybuf[32];
if (XLookupString(&xevent.xkey,
keybuf, sizeof(keybuf), NULL, &state)) {
/*
* FIXME: XLookupString() may yield more than one
* character, so we need a mechanism to allow for
* this (perhaps null keypress events with a
* unicode value)
*/
keysym.unicode = (Uint8) keybuf[0];
}
}
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
#endif // 0
}
break;
/* Key release? */
case KeyRelease:{
#if 0 /* FIXME */
SDL_keysym keysym;
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
/* Check to see if this is a repeated key */
if (X11_KeyRepeat(SDL_Display, &xevent)) {
break;
}
/* Get the translated SDL virtual keysym */
keysym.scancode = keycode;
keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
posted = SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
#endif // 0
}
break;
/* Have we been iconified? */
case UnmapNotify:{
#ifdef DEBUG_XEVENTS
printf("UnmapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_HIDDEN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MINIMIZED, 0,
0);
}
break;
/* Have we been restored? */
case MapNotify:{
#ifdef DEBUG_XEVENTS
printf("MapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_SHOWN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESTORED, 0,
0);
}
break;
/* Have we been resized or moved? */
case ConfigureNotify:{
#ifdef DEBUG_XEVENTS
printf("ConfigureNotify! (resize: %dx%d)\n",
xevent.xconfigure.width, xevent.xconfigure.height);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MOVED,
xevent.xconfigure.x, xevent.xconfigure.y);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESIZED,
xevent.xconfigure.width,
xevent.xconfigure.height);
}
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:{
if ((xevent.xclient.format == 32) &&
(xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_CLOSE, 0,
0);
}
}
break;
/* Do we need to refresh ourselves? */
case Expose:{
#ifdef DEBUG_XEVENTS
printf("Expose (count = %d)\n", xevent.xexpose.count);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_EXPOSED, 0,
0);
}
break;
default:{
#ifdef DEBUG_XEVENTS
printf("Unhandled event %d\n", xevent.type);
#endif
}
break;
}
}
/* Ack! XPending() actually performs a blocking read if no events available */
int
X11_Pending(Display * display)
{
/* Flush the display connection and look to see if events are queued */
XFlush(display);
if (XEventsQueued(display, QueuedAlready)) {
return (1);
}
/* More drastic measures are required -- see if X is ready to talk */
{
static struct timeval zero_time; /* static == 0 */
int x11_fd;
fd_set fdset;
x11_fd = ConnectionNumber(display);
FD_ZERO(&fdset);
FD_SET(x11_fd, &fdset);
if (select(x11_fd + 1, &fdset, NULL, NULL, &zero_time) == 1) {
return (XPending(display));
}
}
/* Oh well, nothing is ready .. */
return (0);
}
void
X11_PumpEvents(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
/* Keep processing pending events */
while (X11_Pending(data->display)) {
X11_DispatchEvent(_this);
}
}
void
X11_SaveScreenSaver(Display * display, int *saved_timeout, BOOL * dpms)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
*saved_timeout = timeout;
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
CARD16 state;
DPMSInfo(display, &state, dpms);
}
}
#else
*dpms = 0;
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
void
X11_DisableScreenSaver(Display * display)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
timeout = 0;
XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
DPMSDisable(display);
}
}
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
void
X11_RestoreScreenSaver(Display * display, int saved_timeout, BOOL dpms)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
timeout = saved_timeout;
XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
if (dpms) {
DPMSEnable(display);
}
}
}
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
/* vi: set ts=4 sw=4 expandtab: */

36
src/video/x11/SDL_x11events.h Normal file
View file

@ -0,0 +1,36 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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"
#ifndef _SDL_x11events_h
#define _SDL_x11events_h
extern void X11_PumpEvents(_THIS);
extern void X11_SaveScreenSaver(Display * display, int *saved_timeout,
BOOL * dpms);
extern void X11_DisableScreenSaver(Display * display);
extern void X11_RestoreScreenSaver(Display * display, int saved_timeout,
BOOL dpms);
#endif /* _SDL_x11events_h */
/* vi: set ts=4 sw=4 expandtab: */

1
src/video/x11/SDL_x11modes.c
View file

@ -106,6 +106,7 @@ X11_InitModes(_THIS)
} }
displaydata->screen = screen; displaydata->screen = screen;
displaydata->visual = vinfo.visual; displaydata->visual = vinfo.visual;
displaydata->depth = vinfo.depth;
SDL_zero(display); SDL_zero(display);
display.desktop_mode = mode; display.desktop_mode = mode;

1
src/video/x11/SDL_x11modes.h
View file

@ -28,6 +28,7 @@ typedef struct
{ {
int screen; int screen;
Visual *visual; Visual *visual;
int depth;
} SDL_DisplayData; } SDL_DisplayData;
//typedef struct //typedef struct

82
src/video/x11/SDL_x11video.c
View file

@ -34,6 +34,49 @@
static int X11_VideoInit(_THIS); static int X11_VideoInit(_THIS);
static void X11_VideoQuit(_THIS); static void X11_VideoQuit(_THIS);
/* Find out what class name we should use */
static char *
get_classname()
{
char *spot;
#if defined(__LINUX__) || defined(__FREEBSD__)
char procfile[1024];
char linkfile[1024];
int linksize;
#endif
/* First allow environment variable override */
spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS");
if (spot) {
return SDL_strdup(spot);
}
/* Next look at the application's executable name */
#if defined(__LINUX__) || defined(__FREEBSD__)
#if defined(__LINUX__)
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid());
#elif defined(__FREEBSD__)
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file",
getpid());
#else
#error Where can we find the executable name?
#endif
linksize = readlink(procfile, linkfile, sizeof(linkfile) - 1);
if (linksize > 0) {
linkfile[linksize] = '\0';
spot = SDL_strrchr(linkfile, '/');
if (spot) {
return SDL_strdup(spot + 1);
} else {
return SDL_strdup(linkfile);
}
}
#endif /* __LINUX__ || __FREEBSD__ */
/* Finally use the default we've used forever */
return SDL_strdup("SDL_App");
}
/* X11 driver bootstrap functions */ /* X11 driver bootstrap functions */
static int static int
@ -127,9 +170,8 @@ X11_CreateDevice(int devindex)
device->SetDisplayMode = X11_SetDisplayMode; device->SetDisplayMode = X11_SetDisplayMode;
// device->SetDisplayGammaRamp = X11_SetDisplayGammaRamp; // device->SetDisplayGammaRamp = X11_SetDisplayGammaRamp;
// device->GetDisplayGammaRamp = X11_GetDisplayGammaRamp; // device->GetDisplayGammaRamp = X11_GetDisplayGammaRamp;
// device->PumpEvents = X11_PumpEvents; device->PumpEvents = X11_PumpEvents;
/*
device->CreateWindow = X11_CreateWindow; device->CreateWindow = X11_CreateWindow;
device->CreateWindowFrom = X11_CreateWindowFrom; device->CreateWindowFrom = X11_CreateWindowFrom;
device->SetWindowTitle = X11_SetWindowTitle; device->SetWindowTitle = X11_SetWindowTitle;
@ -144,6 +186,7 @@ X11_CreateDevice(int devindex)
device->SetWindowGrab = X11_SetWindowGrab; device->SetWindowGrab = X11_SetWindowGrab;
device->DestroyWindow = X11_DestroyWindow; device->DestroyWindow = X11_DestroyWindow;
device->GetWindowWMInfo = X11_GetWindowWMInfo; device->GetWindowWMInfo = X11_GetWindowWMInfo;
/*
#ifdef SDL_VIDEO_OPENGL #ifdef SDL_VIDEO_OPENGL
device->GL_LoadLibrary = X11_GL_LoadLibrary; device->GL_LoadLibrary = X11_GL_LoadLibrary;
device->GL_GetProcAddress = X11_GL_GetProcAddress; device->GL_GetProcAddress = X11_GL_GetProcAddress;
@ -170,6 +213,28 @@ VideoBootStrap X11_bootstrap = {
int int
X11_VideoInit(_THIS) X11_VideoInit(_THIS)
{ {
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
/* Get the window class name, usually the name of the application */
data->classname = get_classname();
/* Open a connection to the X input manager */
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
data->im =
XOpenIM(data->display, NULL, data->classname, data->classname);
}
#endif
/* Save DPMS and screensaver settings */
X11_SaveScreenSaver(data->display, &data->screensaver_timeout,
&data->dpms_enabled);
X11_DisableScreenSaver(data->display);
/* Look up some useful Atoms */
data->WM_DELETE_WINDOW =
XInternAtom(data->display, "WM_DELETE_WINDOW", False);
X11_InitModes(_this); X11_InitModes(_this);
//#if SDL_VIDEO_RENDER_D3D //#if SDL_VIDEO_RENDER_D3D
@ -188,6 +253,19 @@ X11_VideoInit(_THIS)
void void
X11_VideoQuit(_THIS) X11_VideoQuit(_THIS)
{ {
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
if (data->classname) {
SDL_free(data->classname);
}
#ifdef X_HAVE_UTF8_STRING
if (data->im) {
XCloseIM(data->im);
}
#endif
X11_RestoreScreenSaver(data->display, data->screensaver_timeout,
data->dpms_enabled);
X11_QuitModes(_this); X11_QuitModes(_this);
X11_QuitKeyboard(_this); X11_QuitKeyboard(_this);
X11_QuitMouse(_this); X11_QuitMouse(_this);

23
src/video/x11/SDL_x11video.h
View file

@ -30,14 +30,6 @@
#include <X11/Xutil.h> #include <X11/Xutil.h>
#include <X11/Xatom.h> #include <X11/Xatom.h>
//#include "SDL_x11events.h"
//#include "SDL_x11gamma.h"
#include "SDL_x11keyboard.h"
#include "SDL_x11modes.h"
#include "SDL_x11mouse.h"
//#include "SDL_x11opengl.h"
//#include "SDL_x11window.h"
#if SDL_VIDEO_DRIVER_X11_XINERAMA #if SDL_VIDEO_DRIVER_X11_XINERAMA
#include "../Xext/extensions/Xinerama.h" #include "../Xext/extensions/Xinerama.h"
#endif #endif
@ -56,13 +48,28 @@
#include "SDL_x11dyn.h" #include "SDL_x11dyn.h"
#include "SDL_x11events.h"
//#include "SDL_x11gamma.h"
#include "SDL_x11keyboard.h"
#include "SDL_x11modes.h"
#include "SDL_x11mouse.h"
//#include "SDL_x11opengl.h"
#include "SDL_x11window.h"
/* Private display data */ /* Private display data */
typedef struct SDL_VideoData typedef struct SDL_VideoData
{ {
Display *display; Display *display;
char *classname;
XIM im;
int screensaver_timeout;
BOOL dpms_enabled;
int numwindows;
SDL_WindowData **windowlist;
int mouse; int mouse;
int keyboard; int keyboard;
Atom WM_DELETE_WINDOW;
} SDL_VideoData; } SDL_VideoData;
#endif /* _SDL_x11video_h */ #endif /* _SDL_x11video_h */

611
src/video/x11/SDL_x11window.c Normal file
View file

@ -0,0 +1,611 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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_syswm.h"
#include "../SDL_sysvideo.h"
#include "../../events/SDL_keyboard_c.h"
#include "SDL_x11video.h"
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;
SDL_WindowData **windowlist = videodata->windowlist;
/* Allocate the window data */
data = (SDL_WindowData *) SDL_malloc(sizeof(*data));
if (!data) {
SDL_OutOfMemory();
return -1;
}
data->windowID = window->id;
data->window = w;
#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;
/* Associate the data with the window */
windowlist =
(SDL_WindowData **) SDL_realloc(windowlist,
(numwindows +
1) * sizeof(*windowlist));
if (!windowlist) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
windowlist[numwindows++] = data;
videodata->numwindows = numwindows;
videodata->windowlist = windowlist;
/* 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;
}
}
/* 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_MAXIMIZE) {
window->flags |= SDL_WINDOW_MAXIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MAXIMIZED;
}
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;
SDL_SetKeyboardFocus(index, data->windowID);
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 =
(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
Visual *visual;
int depth;
XSetWindowAttributes xattr;
int x, y;
Window w;
XSizeHints *sizehints;
XWMHints *wmhints;
XClassHint *classhints;
#if SDL_VIDEO_DRIVER_X11_XINERAMA
/* FIXME
if ( use_xinerama ) {
x = xinerama_info.x_org;
y = xinerama_info.y_org;
}
*/
#endif
if (window->flags & SDL_WINDOW_OPENGL) {
/* FIXME: get the glx visual */
} else {
visual = displaydata->visual;
depth = displaydata->depth;
}
if (window->flags & SDL_WINDOW_FULLSCREEN) {
xattr.override_redirect = True;
} else {
xattr.override_redirect = False;
}
xattr.background_pixel = 0;
xattr.border_pixel = 0;
if (visual->class == PseudoColor || visual->class == DirectColor) {
xattr.colormap =
XCreateColormap(data->display,
RootWindow(data->display, displaydata->screen),
visual, AllocAll);
} else {
xattr.colormap =
XCreateColormap(data->display,
RootWindow(data->display, displaydata->screen),
visual, AllocNone);
}
if ((window->flags & SDL_WINDOW_FULLSCREEN) ||
window->x == SDL_WINDOWPOS_CENTERED) {
x = (DisplayWidth(data->display, displaydata->screen) -
window->w) / 2;
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
x = 0;
} else {
x = window->x;
}
if ((window->flags & SDL_WINDOW_FULLSCREEN) ||
window->y == SDL_WINDOWPOS_CENTERED) {
y = (DisplayHeight(data->display, displaydata->screen) -
window->h) / 2;
} else if (window->y == SDL_WINDOWPOS_UNDEFINED) {
y = 0;
} else {
y = window->y;
}
w = XCreateWindow(data->display,
RootWindow(data->display, displaydata->screen), x, y,
window->w, window->h, 0, depth, InputOutput, visual,
(CWOverrideRedirect | CWBackPixel | CWBorderPixel |
CWColormap), &xattr);
sizehints = XAllocSizeHints();
if (sizehints) {
if (window->flags & SDL_WINDOW_RESIZABLE) {
sizehints->min_width = 32;
sizehints->min_height = 32;
sizehints->max_height = 4096;
sizehints->max_width = 4096;
} else {
sizehints->min_width = sizehints->max_width = window->w;
sizehints->min_height = sizehints->max_height = window->h;
}
sizehints->flags = PMaxSize | PMinSize;
if (!(window->flags & SDL_WINDOW_FULLSCREEN)
&& window->x != SDL_WINDOWPOS_UNDEFINED
&& window->y != SDL_WINDOWPOS_UNDEFINED) {
sizehints->x = x;
sizehints->y = y;
sizehints->flags |= USPosition;
}
XSetWMNormalHints(data->display, w, sizehints);
XFree(sizehints);
}
if (window->flags & SDL_WINDOW_BORDERLESS) {
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to set MWM hints */
WM_HINTS = XInternAtom(data->display, "_MOTIF_WM_HINTS", True);
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};
XChangeProperty(data->display, w, WM_HINTS, WM_HINTS, 32,
PropModeReplace, (unsigned char *) &MWMHints,
sizeof(MWMHints) / sizeof(long));
set = SDL_TRUE;
}
/* Now try to set KWM hints */
WM_HINTS = XInternAtom(data->display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
long KWMHints = 0;
XChangeProperty(data->display, w,
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &KWMHints,
sizeof(KWMHints) / sizeof(long));
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
WM_HINTS = XInternAtom(data->display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
long GNOMEHints = 0;
XChangeProperty(data->display, w,
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) {
XSetTransientForHint(data->display, w,
RootWindow(data->display,
displaydata->screen));
}
} 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 */
WM_HINTS = XInternAtom(data->display, "_MOTIF_WM_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(data->display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
WM_HINTS = XInternAtom(data->display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
XDeleteProperty(data->display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
WM_HINTS = XInternAtom(data->display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(data->display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if (!set) {
/* NOTE: Does this work? */
XSetTransientForHint(data->display, w, None);
}
}
/* Tell KDE to keep fullscreen windows on top */
if (window->flags & SDL_WINDOW_FULLSCREEN) {
XEvent ev;
long mask;
SDL_zero(ev);
ev.xclient.type = ClientMessage;
ev.xclient.window = RootWindow(data->display, displaydata->screen);
ev.xclient.message_type =
XInternAtom(data->display, "KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = w;
ev.xclient.data.l[1] = CurrentTime;
XSendEvent(data->display,
RootWindow(data->display, displaydata->screen), False,
SubstructureRedirectMask, &ev);
}
/* Set the input hints so we get keyboard input */
wmhints = XAllocWMHints();
if (wmhints) {
wmhints->input = True;
if (window->flags & SDL_WINDOW_MINIMIZED) {
wmhints->initial_state = IconicState;
} else if (window->flags & SDL_WINDOW_SHOWN) {
wmhints->initial_state = NormalState;
} else {
wmhints->initial_state = WithdrawnState;
}
wmhints->flags = InputHint | StateHint;
XSetWMHints(data->display, w, wmhints);
XFree(wmhints);
}
XSelectInput(data->display, w,
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask));
/* 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;
XSetClassHint(data->display, w, classhints);
XFree(classhints);
}
/* Allow the window to be deleted by the window manager */
XSetWMProtocols(data->display, w, &data->WM_DELETE_WINDOW, 1);
/* Finally, show the window */
if (window->flags & SDL_WINDOW_SHOWN) {
XMapRaised(data->display, w);
}
XSync(data->display, False);
if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) {
XDestroyWindow(data->display, w);
return -1;
}
X11_SetWindowTitle(_this, window);
#ifdef SDL_VIDEO_OPENGL
/*
if (window->flags & SDL_WINDOW_OPENGL) {
if (X11_GL_SetupWindow(_this, window) < 0) {
X11_DestroyWindow(_this, window);
return -1;
}
}
*/
#endif
return 0;
}
int
X11_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
Window w = (Window) data;
/* FIXME: Query the title from the existing window */
if (SetupWindowData(_this, window, w, SDL_FALSE) < 0) {
return -1;
}
return 0;
}
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
Atom _NET_WM_NAME = 0;
Atom _NET_WM_ICON_NAME = 0;
/* Look up some useful Atoms */
if (SDL_X11_HAVE_UTF8) {
_NET_WM_NAME = XInternAtom(display, "_NET_WM_NAME", False);
_NET_WM_ICON_NAME = XInternAtom(display, "_NET_WM_ICON_NAME", False);
}
#endif
if (title != NULL) {
char *title_latin1 = SDL_iconv_utf8_latin1((char *) title);
if (!title_latin1) {
SDL_OutOfMemory();
return;
}
status = XStringListToTextProperty(&title_latin1, 1, &titleprop);
SDL_free(title_latin1);
if (status) {
XSetTextProperty(display, data->window, &titleprop, XA_WM_NAME);
XFree(titleprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status =
Xutf8TextListToTextProperty(display, (char **) &title, 1,
XUTF8StringStyle, &titleprop);
if (status == Success) {
XSetTextProperty(display, data->window, &titleprop,
_NET_WM_NAME);
XFree(titleprop.value);
}
}
#endif
}
if (icon != NULL) {
char *icon_latin1 = SDL_iconv_utf8_latin1((char *) icon);
if (!icon_latin1) {
SDL_OutOfMemory();
return;
}
status = XStringListToTextProperty(&icon_latin1, 1, &iconprop);
SDL_free(icon_latin1);
if (status) {
XSetTextProperty(display, data->window, &iconprop,
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) {
XSetTextProperty(display, data->window, &iconprop,
_NET_WM_ICON_NAME);
XFree(iconprop.value);
}
}
#endif
}
}
void
X11_SetWindowPosition(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_DisplayData *displaydata =
(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
Display *display = data->videodata->display;
int x, y;
if ((window->flags & SDL_WINDOW_FULLSCREEN) ||
window->x == SDL_WINDOWPOS_CENTERED) {
x = (DisplayWidth(display, displaydata->screen) - window->w) / 2;
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
x = 0;
} else {
x = window->x;
}
if ((window->flags & SDL_WINDOW_FULLSCREEN) ||
window->y == SDL_WINDOWPOS_CENTERED) {
y = (DisplayHeight(display, displaydata->screen) - window->h) / 2;
} else if (window->y == SDL_WINDOWPOS_UNDEFINED) {
y = 0;
} else {
y = window->y;
}
XMoveWindow(display, data->window, x, y);
}
void
X11_SetWindowSize(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
XMoveWindow(display, data->window, window->w, window->h);
}
void
X11_ShowWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
XMapRaised(display, data->window);
}
void
X11_HideWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
XUnmapWindow(display, data->window);
}
void
X11_RaiseWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
Display *display = data->videodata->display;
XRaiseWindow(display, data->window);
}
void
X11_MaximizeWindow(_THIS, SDL_Window * window)
{
/* FIXME: is this even possible? */
}
void
X11_MinimizeWindow(_THIS, SDL_Window * window)
{
X11_HideWindow(_this, window);
}
void
X11_RestoreWindow(_THIS, SDL_Window * window)
{
X11_ShowWindow(_this, window);
}
void
X11_SetWindowGrab(_THIS, SDL_Window * window)
{
/* FIXME */
}
void
X11_DestroyWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
if (data) {
Display *display = data->videodata->display;
#ifdef SDL_VIDEO_OPENGL
/*
if (window->flags & SDL_WINDOW_OPENGL) {
X11_GL_CleanupWindow(_this, window);
}
*/
#endif
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XDestroyIC(data->ic);
}
#endif
if (data->created) {
XDestroyWindow(display, data->window);
}
SDL_free(data);
}
}
SDL_bool
X11_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
{
if (info->version.major <= SDL_MAJOR_VERSION) {
/* FIXME! */
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: */

54
src/video/x11/SDL_x11window.h Normal file
View file

@ -0,0 +1,54 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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"
#ifndef _SDL_x11window_h
#define _SDL_x11window_h
typedef struct
{
SDL_WindowID windowID;
Window window;
XIC ic;
SDL_bool created;
struct SDL_VideoData *videodata;
} SDL_WindowData;
extern int X11_CreateWindow(_THIS, SDL_Window * window);
extern int X11_CreateWindowFrom(_THIS, SDL_Window * window, const void *data);
extern void X11_SetWindowTitle(_THIS, SDL_Window * window);
extern void X11_SetWindowPosition(_THIS, SDL_Window * window);
extern void X11_SetWindowSize(_THIS, SDL_Window * window);
extern void X11_ShowWindow(_THIS, SDL_Window * window);
extern void X11_HideWindow(_THIS, SDL_Window * window);
extern void X11_RaiseWindow(_THIS, SDL_Window * window);
extern void X11_MaximizeWindow(_THIS, SDL_Window * window);
extern void X11_MinimizeWindow(_THIS, SDL_Window * window);
extern void X11_RestoreWindow(_THIS, SDL_Window * window);
extern void X11_SetWindowGrab(_THIS, SDL_Window * window);
extern void X11_DestroyWindow(_THIS, SDL_Window * window);
extern SDL_bool X11_GetWindowWMInfo(_THIS, SDL_Window * window,
struct SDL_SysWMinfo *info);
#endif /* _SDL_x11window_h */
/* vi: set ts=4 sw=4 expandtab: */