2015-06-21 15:33:46 +00:00
|
|
|
/*
|
|
|
|
Simple DirectMedia Layer
|
2021-01-02 18:25:38 +00:00
|
|
|
Copyright (C) 1997-2021 Sam Lantinga <slouken@libsdl.org>
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
#include "../../SDL_internal.h"
|
|
|
|
|
|
|
|
#if SDL_VIDEO_DRIVER_X11
|
|
|
|
|
|
|
|
#include <unistd.h> /* For getpid() and readlink() */
|
|
|
|
|
|
|
|
#include "SDL_video.h"
|
|
|
|
#include "SDL_mouse.h"
|
2017-08-14 04:16:58 +00:00
|
|
|
#include "SDL_timer.h"
|
Fixed bug 4833 - Use EGL for X11?
Martin Fiedler
To be precise, this is about *desktop OpenGL* on X11. For OpenGL ES, EGL is already used (as it's the only way to get an OpenGL ES context), as Sylvain noted above.
To shine some light on why this is needed:
In 99% of all cases, using GLX on X11 is fine, even though it's effectively deprecated in favor of EGL [1]. However, there's at least one use case that *requires* the OpenGL context being created with EGL instead of GLX, and that's DRM_PRIME interoperability: The function glEGLImageTargetTexture2DOES simply doesn't work with GLX. (Currently, Mesa actually crashes when trying that.)
Some example code:
https://gist.github.com/kajott/d1b29c613be30893c855621edd1f212e
Runs on Intel and open-source AMD drivers just fine (others unconfirmed), but with #define USE_EGL 0 (i.e. forcing it to GLX), it crashes. The same happens when using SDL for window and context creation.
The good news is that most of the pieces for EGL support on X11 are already in place: SDL_egl.c is pretty complete (and used for desktop OpenGL on Wayland, for example), and SDL_x11opengl.c has the aforementioned OpenGL-ES-on-EGL support. However, when it comes to desktop OpenGL, it's hardcoded to fall back to GLX.
I'm not advocating to make EGL the default for desktop OpenGL on X11; don't fix what ain't broken. But something like an SDL_HINT_VIDEO_X11_FORCE_EGL would be very appreciated to make use cases like the above work with SDL.
[1] source: Eric Anholt, major Linux graphics stack developer, 7 years ago already - see last paragraph of https://www.phoronix.com/scan.php?page=news_item&px=MTE3MTI
2020-02-03 16:06:52 +00:00
|
|
|
#include "SDL_hints.h"
|
2015-06-21 15:33:46 +00:00
|
|
|
#include "../SDL_sysvideo.h"
|
|
|
|
#include "../SDL_pixels_c.h"
|
|
|
|
|
|
|
|
#include "SDL_x11video.h"
|
|
|
|
#include "SDL_x11framebuffer.h"
|
|
|
|
#include "SDL_x11shape.h"
|
|
|
|
#include "SDL_x11touch.h"
|
|
|
|
#include "SDL_x11xinput2.h"
|
|
|
|
|
|
|
|
#if SDL_VIDEO_OPENGL_EGL
|
|
|
|
#include "SDL_x11opengles.h"
|
|
|
|
#endif
|
|
|
|
|
2017-08-28 02:15:57 +00:00
|
|
|
#include "SDL_x11vulkan.h"
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
/* Initialization/Query functions */
|
|
|
|
static int X11_VideoInit(_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 */
|
|
|
|
|
2020-09-08 03:10:50 +00:00
|
|
|
static int (*orig_x11_errhandler) (Display *, XErrorEvent *) = NULL;
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
static void
|
|
|
|
X11_DeleteDevice(SDL_VideoDevice * device)
|
|
|
|
{
|
|
|
|
SDL_VideoData *data = (SDL_VideoData *) device->driverdata;
|
2017-08-28 02:15:57 +00:00
|
|
|
if (device->vulkan_config.loader_handle) {
|
|
|
|
device->Vulkan_UnloadLibrary(device);
|
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
if (data->display) {
|
2020-09-08 03:10:50 +00:00
|
|
|
X11_XSetErrorHandler(orig_x11_errhandler);
|
2015-06-21 15:33:46 +00:00
|
|
|
X11_XCloseDisplay(data->display);
|
|
|
|
}
|
2021-03-12 20:58:20 +00:00
|
|
|
if (data->request_display) {
|
|
|
|
X11_XCloseDisplay(data->request_display);
|
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_free(data->windowlist);
|
2021-03-12 20:58:20 +00:00
|
|
|
if (device->wakeup_lock) {
|
|
|
|
SDL_DestroyMutex(device->wakeup_lock);
|
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_free(device->driverdata);
|
|
|
|
SDL_free(device);
|
|
|
|
|
|
|
|
SDL_X11_UnloadSymbols();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* An error handler to reset the vidmode and then call the default handler. */
|
|
|
|
static SDL_bool safety_net_triggered = SDL_FALSE;
|
|
|
|
static int
|
|
|
|
X11_SafetyNetErrHandler(Display * d, XErrorEvent * e)
|
|
|
|
{
|
|
|
|
SDL_VideoDevice *device = NULL;
|
|
|
|
/* if we trigger an error in our error handler, don't try again. */
|
|
|
|
if (!safety_net_triggered) {
|
|
|
|
safety_net_triggered = SDL_TRUE;
|
|
|
|
device = SDL_GetVideoDevice();
|
|
|
|
if (device != NULL) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < device->num_displays; i++) {
|
|
|
|
SDL_VideoDisplay *display = &device->displays[i];
|
|
|
|
if (SDL_memcmp(&display->current_mode, &display->desktop_mode,
|
|
|
|
sizeof (SDL_DisplayMode)) != 0) {
|
|
|
|
X11_SetDisplayMode(device, display, &display->desktop_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (orig_x11_errhandler != NULL) {
|
|
|
|
return orig_x11_errhandler(d, e); /* probably terminate. */
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDL_VideoDevice *
|
|
|
|
X11_CreateDevice(int devindex)
|
|
|
|
{
|
|
|
|
SDL_VideoDevice *device;
|
|
|
|
SDL_VideoData *data;
|
|
|
|
const char *display = NULL; /* Use the DISPLAY environment variable */
|
2020-07-15 01:13:27 +00:00
|
|
|
Display *x11_display = NULL;
|
2020-07-12 23:11:15 +00:00
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
if (!SDL_X11_LoadSymbols()) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Need for threading gl calls. This is also required for the proprietary
|
|
|
|
nVidia driver to be threaded. */
|
|
|
|
X11_XInitThreads();
|
|
|
|
|
2020-07-15 01:13:27 +00:00
|
|
|
/* Open the display first to be sure that X11 is available */
|
|
|
|
x11_display = X11_XOpenDisplay(display);
|
|
|
|
|
|
|
|
if (!x11_display) {
|
|
|
|
SDL_X11_UnloadSymbols();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
/* Initialize all variables that we clean on shutdown */
|
|
|
|
device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
|
|
|
|
if (!device) {
|
|
|
|
SDL_OutOfMemory();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
data = (struct SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
|
|
|
|
if (!data) {
|
|
|
|
SDL_free(device);
|
|
|
|
SDL_OutOfMemory();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
device->driverdata = data;
|
2021-03-12 20:58:20 +00:00
|
|
|
device->wakeup_lock = SDL_CreateMutex();
|
2015-06-21 15:33:46 +00:00
|
|
|
|
2015-04-22 20:50:48 +00:00
|
|
|
data->global_mouse_changed = SDL_TRUE;
|
|
|
|
|
2020-07-15 01:13:27 +00:00
|
|
|
data->display = x11_display;
|
2021-03-12 20:58:20 +00:00
|
|
|
data->request_display = X11_XOpenDisplay(display);
|
|
|
|
if (data->request_display == NULL) {
|
|
|
|
X11_XCloseDisplay(data->display);
|
|
|
|
SDL_free(device->driverdata);
|
|
|
|
SDL_free(device);
|
|
|
|
SDL_X11_UnloadSymbols();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
device->wakeup_lock = SDL_CreateMutex();
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
#ifdef X11_DEBUG
|
|
|
|
X11_XSynchronize(data->display, True);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Hook up an X11 error handler to recover the desktop resolution. */
|
|
|
|
safety_net_triggered = SDL_FALSE;
|
|
|
|
orig_x11_errhandler = X11_XSetErrorHandler(X11_SafetyNetErrHandler);
|
|
|
|
|
|
|
|
/* Set the function pointers */
|
|
|
|
device->VideoInit = X11_VideoInit;
|
|
|
|
device->VideoQuit = X11_VideoQuit;
|
2017-02-11 19:14:48 +00:00
|
|
|
device->ResetTouch = X11_ResetTouch;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->GetDisplayModes = X11_GetDisplayModes;
|
|
|
|
device->GetDisplayBounds = X11_GetDisplayBounds;
|
2016-01-05 04:52:40 +00:00
|
|
|
device->GetDisplayUsableBounds = X11_GetDisplayUsableBounds;
|
2015-07-30 00:19:02 +00:00
|
|
|
device->GetDisplayDPI = X11_GetDisplayDPI;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->SetDisplayMode = X11_SetDisplayMode;
|
|
|
|
device->SuspendScreenSaver = X11_SuspendScreenSaver;
|
|
|
|
device->PumpEvents = X11_PumpEvents;
|
2021-03-12 20:58:20 +00:00
|
|
|
device->WaitEventTimeout = X11_WaitEventTimeout;
|
|
|
|
device->SendWakeupEvent = X11_SendWakeupEvent;
|
2015-06-21 15:33:46 +00:00
|
|
|
|
2017-08-28 07:43:14 +00:00
|
|
|
device->CreateSDLWindow = X11_CreateWindow;
|
|
|
|
device->CreateSDLWindowFrom = X11_CreateWindowFrom;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->SetWindowTitle = X11_SetWindowTitle;
|
|
|
|
device->SetWindowIcon = X11_SetWindowIcon;
|
|
|
|
device->SetWindowPosition = X11_SetWindowPosition;
|
|
|
|
device->SetWindowSize = X11_SetWindowSize;
|
|
|
|
device->SetWindowMinimumSize = X11_SetWindowMinimumSize;
|
|
|
|
device->SetWindowMaximumSize = X11_SetWindowMaximumSize;
|
2016-01-05 07:29:06 +00:00
|
|
|
device->GetWindowBordersSize = X11_GetWindowBordersSize;
|
2016-01-05 07:46:10 +00:00
|
|
|
device->SetWindowOpacity = X11_SetWindowOpacity;
|
2015-04-21 13:45:58 +00:00
|
|
|
device->SetWindowModalFor = X11_SetWindowModalFor;
|
2016-01-05 07:28:56 +00:00
|
|
|
device->SetWindowInputFocus = X11_SetWindowInputFocus;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->ShowWindow = X11_ShowWindow;
|
|
|
|
device->HideWindow = X11_HideWindow;
|
|
|
|
device->RaiseWindow = X11_RaiseWindow;
|
|
|
|
device->MaximizeWindow = X11_MaximizeWindow;
|
|
|
|
device->MinimizeWindow = X11_MinimizeWindow;
|
|
|
|
device->RestoreWindow = X11_RestoreWindow;
|
|
|
|
device->SetWindowBordered = X11_SetWindowBordered;
|
2016-09-30 02:52:41 +00:00
|
|
|
device->SetWindowResizable = X11_SetWindowResizable;
|
2021-04-21 05:41:08 +00:00
|
|
|
device->SetWindowAlwaysOnTop = X11_SetWindowAlwaysOnTop;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->SetWindowFullscreen = X11_SetWindowFullscreen;
|
|
|
|
device->SetWindowGammaRamp = X11_SetWindowGammaRamp;
|
2021-01-26 03:42:14 +00:00
|
|
|
device->SetWindowMouseGrab = X11_SetWindowMouseGrab;
|
2021-01-23 22:22:44 +00:00
|
|
|
device->SetWindowKeyboardGrab = X11_SetWindowKeyboardGrab;
|
2015-06-21 15:33:46 +00:00
|
|
|
device->DestroyWindow = X11_DestroyWindow;
|
|
|
|
device->CreateWindowFramebuffer = X11_CreateWindowFramebuffer;
|
|
|
|
device->UpdateWindowFramebuffer = X11_UpdateWindowFramebuffer;
|
|
|
|
device->DestroyWindowFramebuffer = X11_DestroyWindowFramebuffer;
|
|
|
|
device->GetWindowWMInfo = X11_GetWindowWMInfo;
|
|
|
|
device->SetWindowHitTest = X11_SetWindowHitTest;
|
2018-08-02 20:03:47 +00:00
|
|
|
device->AcceptDragAndDrop = X11_AcceptDragAndDrop;
|
2021-06-04 17:55:30 +00:00
|
|
|
device->FlashWindow = X11_FlashWindow;
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
device->shape_driver.CreateShaper = X11_CreateShaper;
|
|
|
|
device->shape_driver.SetWindowShape = X11_SetWindowShape;
|
|
|
|
device->shape_driver.ResizeWindowShape = X11_ResizeWindowShape;
|
|
|
|
|
|
|
|
#if SDL_VIDEO_OPENGL_GLX
|
|
|
|
device->GL_LoadLibrary = X11_GL_LoadLibrary;
|
|
|
|
device->GL_GetProcAddress = X11_GL_GetProcAddress;
|
|
|
|
device->GL_UnloadLibrary = X11_GL_UnloadLibrary;
|
|
|
|
device->GL_CreateContext = X11_GL_CreateContext;
|
|
|
|
device->GL_MakeCurrent = X11_GL_MakeCurrent;
|
|
|
|
device->GL_SetSwapInterval = X11_GL_SetSwapInterval;
|
|
|
|
device->GL_GetSwapInterval = X11_GL_GetSwapInterval;
|
|
|
|
device->GL_SwapWindow = X11_GL_SwapWindow;
|
|
|
|
device->GL_DeleteContext = X11_GL_DeleteContext;
|
Fixed bug 4833 - Use EGL for X11?
Martin Fiedler
To be precise, this is about *desktop OpenGL* on X11. For OpenGL ES, EGL is already used (as it's the only way to get an OpenGL ES context), as Sylvain noted above.
To shine some light on why this is needed:
In 99% of all cases, using GLX on X11 is fine, even though it's effectively deprecated in favor of EGL [1]. However, there's at least one use case that *requires* the OpenGL context being created with EGL instead of GLX, and that's DRM_PRIME interoperability: The function glEGLImageTargetTexture2DOES simply doesn't work with GLX. (Currently, Mesa actually crashes when trying that.)
Some example code:
https://gist.github.com/kajott/d1b29c613be30893c855621edd1f212e
Runs on Intel and open-source AMD drivers just fine (others unconfirmed), but with #define USE_EGL 0 (i.e. forcing it to GLX), it crashes. The same happens when using SDL for window and context creation.
The good news is that most of the pieces for EGL support on X11 are already in place: SDL_egl.c is pretty complete (and used for desktop OpenGL on Wayland, for example), and SDL_x11opengl.c has the aforementioned OpenGL-ES-on-EGL support. However, when it comes to desktop OpenGL, it's hardcoded to fall back to GLX.
I'm not advocating to make EGL the default for desktop OpenGL on X11; don't fix what ain't broken. But something like an SDL_HINT_VIDEO_X11_FORCE_EGL would be very appreciated to make use cases like the above work with SDL.
[1] source: Eric Anholt, major Linux graphics stack developer, 7 years ago already - see last paragraph of https://www.phoronix.com/scan.php?page=news_item&px=MTE3MTI
2020-02-03 16:06:52 +00:00
|
|
|
#endif
|
|
|
|
#if SDL_VIDEO_OPENGL_EGL
|
|
|
|
#if SDL_VIDEO_OPENGL_GLX
|
|
|
|
if (SDL_GetHintBoolean(SDL_HINT_VIDEO_X11_FORCE_EGL, SDL_FALSE)) {
|
|
|
|
#endif
|
|
|
|
device->GL_LoadLibrary = X11_GLES_LoadLibrary;
|
|
|
|
device->GL_GetProcAddress = X11_GLES_GetProcAddress;
|
|
|
|
device->GL_UnloadLibrary = X11_GLES_UnloadLibrary;
|
|
|
|
device->GL_CreateContext = X11_GLES_CreateContext;
|
|
|
|
device->GL_MakeCurrent = X11_GLES_MakeCurrent;
|
|
|
|
device->GL_SetSwapInterval = X11_GLES_SetSwapInterval;
|
|
|
|
device->GL_GetSwapInterval = X11_GLES_GetSwapInterval;
|
|
|
|
device->GL_SwapWindow = X11_GLES_SwapWindow;
|
|
|
|
device->GL_DeleteContext = X11_GLES_DeleteContext;
|
|
|
|
#if SDL_VIDEO_OPENGL_GLX
|
|
|
|
}
|
|
|
|
#endif
|
2015-06-21 15:33:46 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
device->SetClipboardText = X11_SetClipboardText;
|
|
|
|
device->GetClipboardText = X11_GetClipboardText;
|
|
|
|
device->HasClipboardText = X11_HasClipboardText;
|
|
|
|
device->StartTextInput = X11_StartTextInput;
|
|
|
|
device->StopTextInput = X11_StopTextInput;
|
|
|
|
device->SetTextInputRect = X11_SetTextInputRect;
|
2016-10-01 21:48:18 +00:00
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
device->free = X11_DeleteDevice;
|
|
|
|
|
2017-08-28 07:11:38 +00:00
|
|
|
#if SDL_VIDEO_VULKAN
|
2017-08-28 02:15:57 +00:00
|
|
|
device->Vulkan_LoadLibrary = X11_Vulkan_LoadLibrary;
|
|
|
|
device->Vulkan_UnloadLibrary = X11_Vulkan_UnloadLibrary;
|
|
|
|
device->Vulkan_GetInstanceExtensions = X11_Vulkan_GetInstanceExtensions;
|
|
|
|
device->Vulkan_CreateSurface = X11_Vulkan_CreateSurface;
|
|
|
|
#endif
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
return device;
|
|
|
|
}
|
|
|
|
|
|
|
|
VideoBootStrap X11_bootstrap = {
|
|
|
|
"x11", "SDL X11 video driver",
|
2020-07-12 23:11:15 +00:00
|
|
|
X11_CreateDevice
|
2015-06-21 15:33:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int (*handler) (Display *, XErrorEvent *) = NULL;
|
|
|
|
static int
|
|
|
|
X11_CheckWindowManagerErrorHandler(Display * d, XErrorEvent * e)
|
|
|
|
{
|
|
|
|
if (e->error_code == BadWindow) {
|
|
|
|
return (0);
|
|
|
|
} else {
|
|
|
|
return (handler(d, e));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
X11_CheckWindowManager(_THIS)
|
|
|
|
{
|
|
|
|
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
|
|
|
|
Display *display = data->display;
|
|
|
|
Atom _NET_SUPPORTING_WM_CHECK;
|
|
|
|
int status, real_format;
|
|
|
|
Atom real_type;
|
|
|
|
unsigned long items_read = 0, items_left = 0;
|
|
|
|
unsigned char *propdata = NULL;
|
|
|
|
Window wm_window = 0;
|
|
|
|
#ifdef DEBUG_WINDOW_MANAGER
|
|
|
|
char *wm_name;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Set up a handler to gracefully catch errors */
|
|
|
|
X11_XSync(display, False);
|
|
|
|
handler = X11_XSetErrorHandler(X11_CheckWindowManagerErrorHandler);
|
|
|
|
|
|
|
|
_NET_SUPPORTING_WM_CHECK = X11_XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
|
|
|
|
status = X11_XGetWindowProperty(display, DefaultRootWindow(display), _NET_SUPPORTING_WM_CHECK, 0L, 1L, False, XA_WINDOW, &real_type, &real_format, &items_read, &items_left, &propdata);
|
|
|
|
if (status == Success) {
|
|
|
|
if (items_read) {
|
|
|
|
wm_window = ((Window*)propdata)[0];
|
|
|
|
}
|
|
|
|
if (propdata) {
|
|
|
|
X11_XFree(propdata);
|
|
|
|
propdata = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wm_window) {
|
|
|
|
status = X11_XGetWindowProperty(display, wm_window, _NET_SUPPORTING_WM_CHECK, 0L, 1L, False, XA_WINDOW, &real_type, &real_format, &items_read, &items_left, &propdata);
|
|
|
|
if (status != Success || !items_read || wm_window != ((Window*)propdata)[0]) {
|
|
|
|
wm_window = None;
|
|
|
|
}
|
|
|
|
if (status == Success && propdata) {
|
|
|
|
X11_XFree(propdata);
|
|
|
|
propdata = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the error handler, we're done checking */
|
|
|
|
X11_XSync(display, False);
|
|
|
|
X11_XSetErrorHandler(handler);
|
|
|
|
|
|
|
|
if (!wm_window) {
|
|
|
|
#ifdef DEBUG_WINDOW_MANAGER
|
|
|
|
printf("Couldn't get _NET_SUPPORTING_WM_CHECK property\n");
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
data->net_wm = SDL_TRUE;
|
|
|
|
|
|
|
|
#ifdef DEBUG_WINDOW_MANAGER
|
|
|
|
wm_name = X11_GetWindowTitle(_this, wm_window);
|
|
|
|
printf("Window manager: %s\n", wm_name);
|
|
|
|
SDL_free(wm_name);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
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();
|
|
|
|
|
|
|
|
/* Get the process PID to be associated to the window */
|
|
|
|
data->pid = getpid();
|
|
|
|
|
2016-01-05 07:27:26 +00:00
|
|
|
/* I have no idea how random this actually is, or has to be. */
|
|
|
|
data->window_group = (XID) (((size_t) data->pid) ^ ((size_t) _this));
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
/* Look up some useful Atoms */
|
|
|
|
#define GET_ATOM(X) data->X = X11_XInternAtom(data->display, #X, False)
|
|
|
|
GET_ATOM(WM_PROTOCOLS);
|
|
|
|
GET_ATOM(WM_DELETE_WINDOW);
|
2016-01-05 07:27:50 +00:00
|
|
|
GET_ATOM(WM_TAKE_FOCUS);
|
2015-06-21 15:33:46 +00:00
|
|
|
GET_ATOM(_NET_WM_STATE);
|
|
|
|
GET_ATOM(_NET_WM_STATE_HIDDEN);
|
|
|
|
GET_ATOM(_NET_WM_STATE_FOCUSED);
|
|
|
|
GET_ATOM(_NET_WM_STATE_MAXIMIZED_VERT);
|
|
|
|
GET_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ);
|
|
|
|
GET_ATOM(_NET_WM_STATE_FULLSCREEN);
|
2016-01-05 06:30:40 +00:00
|
|
|
GET_ATOM(_NET_WM_STATE_ABOVE);
|
|
|
|
GET_ATOM(_NET_WM_STATE_SKIP_TASKBAR);
|
|
|
|
GET_ATOM(_NET_WM_STATE_SKIP_PAGER);
|
2015-06-21 15:33:46 +00:00
|
|
|
GET_ATOM(_NET_WM_ALLOWED_ACTIONS);
|
|
|
|
GET_ATOM(_NET_WM_ACTION_FULLSCREEN);
|
|
|
|
GET_ATOM(_NET_WM_NAME);
|
|
|
|
GET_ATOM(_NET_WM_ICON_NAME);
|
|
|
|
GET_ATOM(_NET_WM_ICON);
|
|
|
|
GET_ATOM(_NET_WM_PING);
|
2016-01-05 07:46:10 +00:00
|
|
|
GET_ATOM(_NET_WM_WINDOW_OPACITY);
|
2016-01-04 21:25:27 +00:00
|
|
|
GET_ATOM(_NET_WM_USER_TIME);
|
2015-06-21 15:33:46 +00:00
|
|
|
GET_ATOM(_NET_ACTIVE_WINDOW);
|
2016-03-04 23:47:19 +00:00
|
|
|
GET_ATOM(_NET_FRAME_EXTENTS);
|
2021-03-12 20:58:20 +00:00
|
|
|
GET_ATOM(_SDL_WAKEUP);
|
2015-06-21 15:33:46 +00:00
|
|
|
GET_ATOM(UTF8_STRING);
|
|
|
|
GET_ATOM(PRIMARY);
|
|
|
|
GET_ATOM(XdndEnter);
|
|
|
|
GET_ATOM(XdndPosition);
|
|
|
|
GET_ATOM(XdndStatus);
|
|
|
|
GET_ATOM(XdndTypeList);
|
|
|
|
GET_ATOM(XdndActionCopy);
|
|
|
|
GET_ATOM(XdndDrop);
|
|
|
|
GET_ATOM(XdndFinished);
|
|
|
|
GET_ATOM(XdndSelection);
|
2015-08-15 04:36:39 +00:00
|
|
|
GET_ATOM(XKLAVIER_STATE);
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
/* Detect the window manager */
|
|
|
|
X11_CheckWindowManager(_this);
|
|
|
|
|
|
|
|
if (X11_InitModes(_this) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
X11_InitXinput2(_this);
|
|
|
|
|
|
|
|
if (X11_InitKeyboard(_this) != 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
X11_InitMouse(_this);
|
|
|
|
|
|
|
|
X11_InitTouch(_this);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
X11_VideoQuit(_THIS)
|
|
|
|
{
|
|
|
|
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
|
|
|
|
|
2017-07-31 17:49:22 +00:00
|
|
|
if (data->clipboard_window) {
|
|
|
|
X11_XDestroyWindow(data->display, data->clipboard_window);
|
|
|
|
}
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_free(data->classname);
|
|
|
|
#ifdef X_HAVE_UTF8_STRING
|
|
|
|
if (data->im) {
|
|
|
|
X11_XCloseIM(data->im);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
X11_QuitModes(_this);
|
|
|
|
X11_QuitKeyboard(_this);
|
|
|
|
X11_QuitMouse(_this);
|
|
|
|
X11_QuitTouch(_this);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_bool
|
|
|
|
X11_UseDirectColorVisuals(void)
|
|
|
|
{
|
|
|
|
return SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ? SDL_FALSE : SDL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* SDL_VIDEO_DRIVER_X11 */
|
|
|
|
|
|
|
|
/* vim: set ts=4 sw=4 expandtab: */
|