int
WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
HWND hwnd = (HWND) data;
LPTSTR title;
int titleLen;
/* Query the title from the existing window */
titleLen = GetWindowTextLength(hwnd);
title = SDL_stack_alloc(TCHAR, titleLen + 1);
if (title) {
titleLen = GetWindowText(hwnd, title, titleLen);
} else {
titleLen = 0;
}
if (titleLen > 0) {
window->title = WIN_StringToUTF8(title);
}
if (title) {
SDL_stack_free(title);
}
if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
return -1;
}
// Urho3D: if window will be used for OpenGL, choose pixel format
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
return -1;
}
}
return 0;
}
int
WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
HWND hwnd = (HWND) data;
LPTSTR title;
int titleLen;
/* Query the title from the existing window */
titleLen = GetWindowTextLength(hwnd);
title = SDL_stack_alloc(TCHAR, titleLen + 1);
if (title) {
titleLen = GetWindowText(hwnd, title, titleLen);
} else {
titleLen = 0;
}
if (titleLen > 0) {
window->title = WIN_StringToUTF8(title);
}
if (title) {
SDL_stack_free(title);
}
if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
return -1;
}
return 0;
}
int
WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
HWND hwnd = (HWND) data;
LPTSTR title;
int titleLen;
/* Query the title from the existing window */
titleLen = GetWindowTextLength(hwnd);
title = SDL_stack_alloc(TCHAR, titleLen + 1);
if (title) {
titleLen = GetWindowText(hwnd, title, titleLen);
} else {
titleLen = 0;
}
if (titleLen > 0) {
window->title = WIN_StringToUTF8(title);
}
if (title) {
SDL_stack_free(title);
}
if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
return -1;
}
// Urho3D: if window will be used for OpenGL, choose pixel format
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
return -1;
}
}
#if SDL_VIDEO_OPENGL_WGL
{
const char *hint = SDL_GetHint(SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT);
if (hint) {
// This hint is a pointer (in string form) of the address of
// the window to share a pixel format with
SDL_Window *otherWindow = NULL;
SDL_sscanf(hint, "%p", (void**)&otherWindow);
// Do some error checking on the pointer
if (otherWindow != NULL && otherWindow->magic == &_this->window_magic)
{
// If the otherWindow has SDL_WINDOW_OPENGL set, set it for the new window as well
if (otherWindow->flags & SDL_WINDOW_OPENGL)
{
window->flags |= SDL_WINDOW_OPENGL;
if(!WIN_GL_SetPixelFormatFrom(_this, otherWindow, window)) {
return -1;
}
}
}
}
}
#endif
return 0;
}
int
X11_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
Window w = (Window) data;
window->title = X11_GetWindowTitle(_this, w);
if (SetupWindowData(_this, window, w, SDL_FALSE) < 0) {
return -1;
}
return 0;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
HWND hwnd;
RECT rect;
DWORD style = STYLE_BASIC;
int x, y;
int w, h;
style |= GetWindowStyle(window);
/* Figure out what the window area will be */
rect.left = window->x;
rect.top = window->y;
rect.right = window->x + window->w;
rect.bottom = window->y + window->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
x = rect.left;
y = rect.top;
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
if (!hwnd) {
WIN_SetError("Couldn't create window");
return -1;
}
WIN_PumpEvents(_this);
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
DestroyWindow(hwnd);
return -1;
}
#if SDL_VIDEO_OPENGL_WGL
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
return 0;
}
//--------------------------------------------------------------------------
void VeWindows::_CreateWindow(Window* pkWindow)
{
WNDCLASSEXA kClass;
kClass.cbSize = sizeof(WNDCLASSEXA);
kClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
kClass.lpfnWndProc = WndProc;
kClass.cbClsExtra = 0;
kClass.cbWndExtra = 0;
kClass.hInstance = m_kParams.m_hInstance;
kClass.hIcon = 0;
kClass.hCursor = LoadCursor(NULL, IDC_ARROW);
kClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
kClass.lpszMenuName = NULL;
kClass.lpszClassName = m_kParams.m_pcAppName;
kClass.hIconSm = 0;
VE_ASSERT_NOT_EQ(RegisterClassExA(&kClass), VE_FALSE);
HWND hWnd;
RECT kRect;
DWORD dwStyle = STYLE_BASIC;
VeInt32 x, y;
VeInt32 w, h;
dwStyle |= GetWindowStyle(pkWindow);
kRect.left = pkWindow->x;
kRect.top = pkWindow->y;
kRect.right = pkWindow->x + pkWindow->w;
kRect.bottom = pkWindow->y + pkWindow->h;
AdjustWindowRectEx(&kRect, dwStyle, FALSE, 0);
x = kRect.left;
y = kRect.top;
w = (kRect.right - kRect.left);
h = (kRect.bottom - kRect.top);
hWnd = CreateWindowA(m_kParams.m_pcAppName, "", dwStyle, x, y, w, h, NULL, NULL,
m_kParams.m_hInstance, NULL);
VE_ASSERT(hWnd);
_PumpEvents();
SetupWindowData(pkWindow, hWnd, VE_TRUE);
_DisableIME(pkWindow);
}
//--------------------------------------------------------------------------
bool WindowsVideoDevice::_CreateWindow(VeWindow::Data* pkWindow) noexcept
{
VE_ASSERT(pkWindow);
HWND hwnd;
RECT rect;
DWORD style = STYLE_BASIC;
VeInt32 x, y;
VeInt32 w, h;
style |= GetWindowStyle(pkWindow);
rect.left = pkWindow->x;
rect.top = pkWindow->y;
rect.right = pkWindow->x + pkWindow->w;
rect.bottom = pkWindow->y + pkWindow->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
x = rect.left;
y = rect.top;
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
hwnd = CreateWindowA(m_kAppName, "", style, x, y, w, h,
nullptr, nullptr, m_hInstance, nullptr);
if (!hwnd)
{
return false;
}
_PumpEvents();
if (!SetupWindowData(pkWindow, hwnd, VE_TRUE))
{
DestroyWindow(hwnd);
return false;
}
return true;
}
//--------------------------------------------------------------------------
bool WindowsVideoDevice::_CreateWindowFrom(VeWindow::Data* pkWindow,
const void* pvData) noexcept
{
VE_ASSERT(pkWindow && pvData);
HWND hWnd = (HWND)pvData;
VeInt32 i32TitleLen = GetWindowTextLengthA(hWnd);
if (i32TitleLen > 0)
{
VeChar8* pcTitle = VeStackAlloc(VeChar8, i32TitleLen + 1);
VE_ASSERT(pcTitle);
i32TitleLen = GetWindowTextA(hWnd, pcTitle, i32TitleLen);
VE_ASSERT(i32TitleLen > 0);
pkWindow->m_kTitle = pcTitle;
VeStackFree(pcTitle);
}
if (!SetupWindowData(pkWindow, hWnd, VE_FALSE))
{
return false;
}
return true;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
HWND hwnd;
RECT rect;
DWORD style = STYLE_BASIC;
int x, y;
int w, h;
style |= GetWindowStyle(window);
/* Figure out what the window area will be */
rect.left = window->x;
rect.top = window->y;
rect.right = window->x + window->w;
rect.bottom = window->y + window->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
x = rect.left;
y = rect.top;
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
if (!hwnd) {
return WIN_SetError("Couldn't create window");
}
WIN_PumpEvents(_this);
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
DestroyWindow(hwnd);
return -1;
}
#if SDL_VIDEO_OPENGL_WGL
/* We need to initialize the extensions before deciding how to create ES profiles */
if (window->flags & SDL_WINDOW_OPENGL) {
WIN_GL_InitExtensions(_this);
}
#endif
#if SDL_VIDEO_OPENGL_ES2
if ((window->flags & SDL_WINDOW_OPENGL) &&
_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES
#if SDL_VIDEO_OPENGL_WGL
&& (!_this->gl_data || !_this->gl_data->HAS_WGL_EXT_create_context_es2_profile)
#endif
) {
#if SDL_VIDEO_OPENGL_EGL
if (WIN_GLES_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
#else
return SDL_SetError("Could not create GLES window surface (no EGL support available)");
#endif /* SDL_VIDEO_OPENGL_EGL */
} else
#endif /* SDL_VIDEO_OPENGL_ES2 */
#if SDL_VIDEO_OPENGL_WGL
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
return 0;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
RAWINPUTDEVICE Rid;
AXIS TabX, TabY;
LOGCONTEXTA lc;
HWND hwnd;
HWND top;
RECT rect;
SDL_Rect bounds;
DWORD style = (WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
int x, y;
int w, h;
if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) {
style |= WS_POPUP;
} else {
style |= (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
}
if ((window->flags & SDL_WINDOW_RESIZABLE)
&& !(window->flags & SDL_WINDOW_FULLSCREEN)) {
style |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
}
/* Figure out what the window area will be */
if (window->flags & SDL_WINDOW_FULLSCREEN) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
rect.left = 0;
rect.top = 0;
rect.right = window->w;
rect.bottom = window->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
WIN_GetDisplayBounds(_this, display, &bounds);
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->x == SDL_WINDOWPOS_CENTERED) {
x = bounds.x + (bounds.w - window->w) / 2;
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
if (bounds.x == 0) {
x = CW_USEDEFAULT;
} else {
x = bounds.x;
}
} else {
x = bounds.x + window->x + rect.left;
}
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->y == SDL_WINDOWPOS_CENTERED) {
y = bounds.y + (bounds.h - window->h) / 2;
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
if (bounds.x == 0) {
y = CW_USEDEFAULT;
} else {
y = bounds.y;
}
} else {
y = bounds.y + window->y + rect.top;
}
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
if (!hwnd) {
WIN_SetError("Couldn't create window");
return -1;
}
/* we're configuring the tablet data. See Wintab reference for more info */
if (videodata->wintabDLL
&& videodata->WTInfoA(WTI_DEFSYSCTX, 0, &lc) != 0) {
lc.lcPktData = PACKETDATA;
lc.lcPktMode = PACKETMODE;
lc.lcOptions |= CXO_MESSAGES;
lc.lcOptions |= CXO_SYSTEM;
lc.lcMoveMask = PACKETDATA;
lc.lcBtnDnMask = lc.lcBtnUpMask = PACKETDATA;
videodata->WTInfoA(WTI_DEVICES, DVC_X, &TabX);
videodata->WTInfoA(WTI_DEVICES, DVC_Y, &TabY);
lc.lcInOrgX = 0;
lc.lcInOrgY = 0;
lc.lcInExtX = TabX.axMax;
lc.lcInExtY = TabY.axMax;
lc.lcOutOrgX = 0;
lc.lcOutOrgY = 0;
lc.lcOutExtX = GetSystemMetrics(SM_CXSCREEN);
lc.lcOutExtY = -GetSystemMetrics(SM_CYSCREEN);
if (window->id > highestId) {
HCTX *tmp_hctx;
highestId = window->id;
tmp_hctx =
(HCTX *) SDL_realloc(g_hCtx, (highestId + 1) * sizeof(HCTX));
if (!tmp_hctx) {
SDL_OutOfMemory();
DestroyWindow(hwnd);
return -1;
}
g_hCtx = tmp_hctx;
}
g_hCtx[window->id] = videodata->WTOpenA(hwnd, &lc, TRUE);
}
#ifndef _WIN32_WCE /* has no RawInput */
/* we're telling the window, we want it to report raw input events from mice */
Rid.usUsagePage = 0x01;
Rid.usUsage = 0x02;
Rid.dwFlags = RIDEV_INPUTSINK;
Rid.hwndTarget = hwnd;
RegisterRawInputDevices(&Rid, 1, sizeof(Rid));
#endif
WIN_PumpEvents(_this);
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
DestroyWindow(hwnd);
return -1;
}
#ifdef SDL_VIDEO_OPENGL_WGL
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
return 0;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
HWND hwnd, parent = NULL;
DWORD style = STYLE_BASIC;
int x, y;
int w, h;
if (window->flags & SDL_WINDOW_SKIP_TASKBAR) {
parent = CreateWindow(SDL_Appname, TEXT(""), STYLE_BASIC, 0, 0, 32, 32, NULL, NULL, SDL_Instance, NULL);
}
style |= GetWindowStyle(window);
/* Figure out what the window area will be */
WIN_AdjustWindowRectWithStyle(window, style, FALSE, &x, &y, &w, &h, SDL_FALSE);
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, parent, NULL,
SDL_Instance, NULL);
if (!hwnd) {
return WIN_SetError("Couldn't create window");
}
WIN_PumpEvents(_this);
if (SetupWindowData(_this, window, hwnd, parent, SDL_TRUE) < 0) {
DestroyWindow(hwnd);
if (parent) {
DestroyWindow(parent);
}
return -1;
}
/* Inform Windows of the frame change so we can respond to WM_NCCALCSIZE */
SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
if (window->flags & SDL_WINDOW_MINIMIZED) {
ShowWindow(hwnd, SW_SHOWMINNOACTIVE);
}
if (!(window->flags & SDL_WINDOW_OPENGL)) {
return 0;
}
/* The rest of this macro mess is for OpenGL or OpenGL ES windows */
#if SDL_VIDEO_OPENGL_ES2
if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES
#if SDL_VIDEO_OPENGL_WGL
&& (!_this->gl_data || WIN_GL_UseEGL(_this))
#endif /* SDL_VIDEO_OPENGL_WGL */
) {
#if SDL_VIDEO_OPENGL_EGL
if (WIN_GLES_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
return 0;
#else
return SDL_SetError("Could not create GLES window surface (EGL support not configured)");
#endif /* SDL_VIDEO_OPENGL_EGL */
}
#endif /* SDL_VIDEO_OPENGL_ES2 */
#if SDL_VIDEO_OPENGL_WGL
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
#else
return SDL_SetError("Could not create GL window (WGL support not configured)");
#endif
return 0;
}
int
X11_CreateWindow(_THIS, SDL_Window * window)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
SDL_DisplayData *displaydata =
(SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
Display *display = data->display;
int screen = displaydata->screen;
Visual *visual;
int depth;
XSetWindowAttributes xattr;
Window w;
XSizeHints *sizehints;
XWMHints *wmhints;
XClassHint *classhints;
Atom _NET_WM_WINDOW_TYPE;
Atom _NET_WM_WINDOW_TYPE_NORMAL;
int wmstate_count;
Atom wmstate_atoms[3];
#if SDL_VIDEO_DRIVER_X11_XINERAMA
/* FIXME
if ( use_xinerama ) {
x = xinerama_info.x_org;
y = xinerama_info.y_org;
}
*/
#endif
#if SDL_VIDEO_OPENGL_GLX
if (window->flags & SDL_WINDOW_OPENGL) {
XVisualInfo *vinfo;
vinfo = X11_GL_GetVisual(_this, display, screen);
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
#endif
#ifdef SDL_VIDEO_DRIVER_PANDORA
if (window->flags & SDL_WINDOW_OPENGL) {
XVisualInfo *vinfo;
vinfo = X11_GLES_GetVisual(_this, display, screen);
if (!vinfo) {
return -1;
}
visual = vinfo->visual;
depth = vinfo->depth;
XFree(vinfo);
} else
#endif
{
visual = displaydata->visual;
depth = displaydata->depth;
}
xattr.override_redirect = False;
xattr.background_pixel = 0;
xattr.border_pixel = 0;
xattr.colormap = XCreateColormap(display, RootWindow(display, screen), visual, AllocNone);
w = XCreateWindow(display, RootWindow(display, screen),
window->x, window->y, window->w, window->h,
0, depth, InputOutput, visual,
(CWOverrideRedirect | CWBackPixel | CWBorderPixel |
CWColormap), &xattr);
if (!w) {
SDL_SetError("Couldn't create window");
return -1;
}
#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
sizehints = XAllocSizeHints();
if (sizehints) {
if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
sizehints->min_width = sizehints->max_width = window->w;
sizehints->min_height = sizehints->max_height = window->h;
sizehints->flags = PMaxSize | PMinSize;
}
sizehints->x = window->x;
sizehints->y = window->y;
sizehints->flags |= USPosition;
XSetWMNormalHints(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(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(display, w, WM_HINTS, WM_HINTS, 32,
PropModeReplace, (unsigned char *) &MWMHints,
sizeof(MWMHints) / 4);
set = SDL_TRUE;
}
/* Now try to set KWM hints */
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
long KWMHints = 0;
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &KWMHints,
sizeof(KWMHints) / 4);
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
long GNOMEHints = 0;
XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &GNOMEHints,
sizeof(GNOMEHints) / 4);
set = SDL_TRUE;
}
/* Finally set the transient hints if necessary */
if (!set) {
XSetTransientForHint(display, w, RootWindow(display, 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(display, "_MOTIF_WM_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
XDeleteProperty(display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
WM_HINTS = XInternAtom(display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(display, w, WM_HINTS);
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if (!set) {
XDeleteProperty(display, w, XA_WM_TRANSIENT_FOR);
}
}
/* Set the input hints so we get keyboard input */
wmhints = XAllocWMHints();
if (wmhints) {
wmhints->input = True;
wmhints->flags = InputHint;
XSetWMHints(display, w, wmhints);
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;
XSetClassHint(display, w, classhints);
XFree(classhints);
}
/* 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);
}
/* 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);
/* Allow the window to be deleted by the window manager */
XSetWMProtocols(display, w, &data->WM_DELETE_WINDOW, 1);
if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) {
XDestroyWindow(display, w);
return -1;
}
#ifdef X_HAVE_UTF8_STRING
{
Uint32 fevent = 0;
pXGetICValues(((SDL_WindowData *) window->driverdata)->ic,
XNFilterEvents, &fevent, NULL);
XSelectInput(display, w,
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask | fevent));
}
#else
{
XSelectInput(display, w,
(FocusChangeMask | EnterWindowMask | LeaveWindowMask |
ExposureMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | KeyReleaseMask |
PropertyChangeMask | StructureNotifyMask |
KeymapStateMask));
}
#endif
XFlush(display);
return 0;
}
