godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-08 12:40:44 +00:00
Code Releases Wiki Activity

Fix minimize/maximize not taking effect in X11.

Browse Source 
Attempts to construct an X11 window in an initial state of
minimized/maximized would fail due to the window being unmapped.
We simply check for failed mode changes during an unmap and reapply
them if necessary.
This commit is contained in:
MatthewZelriche
2022-08-30 12:52:24 -06:00
parent de5f13e935
commit 87937bcf87
2 changed files with 92 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
platform/linuxbsd/display_server_x11.cpp
View File

@@ -1823,6 +1823,47 @@ bool DisplayServerX11::_window_maximize_check(WindowID p_window, const char *p_a
return retval; return retval;
} }
bool DisplayServerX11::_window_minimize_check(WindowID p_window) const {
const WindowData &wd = windows[p_window];
// Using ICCCM -- Inter-Client Communication Conventions Manual
Atom property = XInternAtom(x11_display, "WM_STATE", True);
if (property == None) {
return false;
}
Atom type;
int format;
unsigned long len;
unsigned long remaining;
unsigned char *data = nullptr;
int result = XGetWindowProperty(
x11_display,
wd.x11_window,
property,
0,
32,
False,
AnyPropertyType,
&type,
&format,
&len,
&remaining,
&data);
if (result == Success && data) {
long *state = (long *)data;
if (state[0] == WM_IconicState) {
XFree(data);
return true;
}
XFree(data);
}
return false;
}
bool DisplayServerX11::_window_fullscreen_check(WindowID p_window) const { bool DisplayServerX11::_window_fullscreen_check(WindowID p_window) const {
ERR_FAIL_COND_V(!windows.has(p_window), false); ERR_FAIL_COND_V(!windows.has(p_window), false);
const WindowData &wd = windows[p_window]; const WindowData &wd = windows[p_window];
@@ -1869,11 +1910,15 @@ bool DisplayServerX11::_window_fullscreen_check(WindowID p_window) const {
return retval; return retval;
} }
void DisplayServerX11::_validate_fullscreen_on_map(WindowID p_window) { void DisplayServerX11::_validate_mode_on_map(WindowID p_window) {
// Check if we applied any window modes that didn't take effect while unmapped
const WindowData &wd = windows[p_window]; const WindowData &wd = windows[p_window];
if (wd.fullscreen && !_window_fullscreen_check(p_window)) { if (wd.fullscreen && !_window_fullscreen_check(p_window)) {
// Unmapped fullscreen attempt didn't take effect, redo...
_set_wm_fullscreen(p_window, true); _set_wm_fullscreen(p_window, true);
} else if (wd.maximized && !_window_maximize_check(p_window, "_NET_WM_STATE")) {
_set_wm_maximized(p_window, true);
} else if (wd.minimized && !_window_minimize_check(p_window)) {
_set_wm_minimized(p_window, true);
} }
} }
@@ -1911,6 +1956,37 @@ void DisplayServerX11::_set_wm_maximized(WindowID p_window, bool p_enabled) {
usleep(10000); usleep(10000);
} }
} }
wd.maximized = p_enabled;
}
void DisplayServerX11::_set_wm_minimized(WindowID p_window, bool p_enabled) {
WindowData &wd = windows[p_window];
// Using ICCCM -- Inter-Client Communication Conventions Manual
XEvent xev;
Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_change;
xev.xclient.format = 32;
xev.xclient.data.l[0] = p_enabled ? WM_IconicState : WM_NormalState;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
xev.xclient.data.l[1] = wm_hidden;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
wd.minimized = p_enabled;
} }
void DisplayServerX11::_set_wm_fullscreen(WindowID p_window, bool p_enabled) { void DisplayServerX11::_set_wm_fullscreen(WindowID p_window, bool p_enabled) {
@@ -1992,32 +2068,7 @@ void DisplayServerX11::window_set_mode(WindowMode p_mode, WindowID p_window) {
//do nothing //do nothing
} break; } break;
case WINDOW_MODE_MINIMIZED: { case WINDOW_MODE_MINIMIZED: {
//Un-Minimize _set_wm_minimized(p_window, false);
// Using ICCCM -- Inter-Client Communication Conventions Manual
XEvent xev;
Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_change;
xev.xclient.format = 32;
xev.xclient.data.l[0] = WM_NormalState;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
xev.xclient.data.l[1] = wm_hidden;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
} break; } break;
case WINDOW_MODE_EXCLUSIVE_FULLSCREEN: case WINDOW_MODE_EXCLUSIVE_FULLSCREEN:
case WINDOW_MODE_FULLSCREEN: { case WINDOW_MODE_FULLSCREEN: {
@@ -2046,31 +2097,7 @@ void DisplayServerX11::window_set_mode(WindowMode p_mode, WindowID p_window) {
//do nothing //do nothing
} break; } break;
case WINDOW_MODE_MINIMIZED: { case WINDOW_MODE_MINIMIZED: {
// Using ICCCM -- Inter-Client Communication Conventions Manual _set_wm_minimized(p_window, true);
XEvent xev;
Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_change;
xev.xclient.format = 32;
xev.xclient.data.l[0] = WM_IconicState;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = wd.x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
xev.xclient.data.l[1] = wm_hidden;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
} break; } break;
case WINDOW_MODE_EXCLUSIVE_FULLSCREEN: case WINDOW_MODE_EXCLUSIVE_FULLSCREEN:
case WINDOW_MODE_FULLSCREEN: { case WINDOW_MODE_FULLSCREEN: {
@@ -2105,41 +2132,10 @@ DisplayServer::WindowMode DisplayServerX11::window_get_mode(WindowID p_window) c
return WINDOW_MODE_MAXIMIZED; return WINDOW_MODE_MAXIMIZED;
} }
{ // Test minimized. {
// Using ICCCM -- Inter-Client Communication Conventions Manual if (_window_minimize_check(p_window)) {
Atom property = XInternAtom(x11_display, "WM_STATE", True);
if (property == None) {
return WINDOW_MODE_WINDOWED;
}
Atom type;
int format;
unsigned long len;
unsigned long remaining;
unsigned char *data = nullptr;
int result = XGetWindowProperty(
x11_display,
wd.x11_window,
property,
0,
32,
False,
AnyPropertyType,
&type,
&format,
&len,
&remaining,
&data);
if (result == Success && data) {
long *state = (long *)data;
if (state[0] == WM_IconicState) {
XFree(data);
return WINDOW_MODE_MINIMIZED; return WINDOW_MODE_MINIMIZED;
} }
XFree(data);
}
} }
// All other discarded, return windowed. // All other discarded, return windowed.
@@ -3658,9 +3654,6 @@ void DisplayServerX11::process_events() {
const WindowData &wd = windows[window_id]; const WindowData &wd = windows[window_id];
// Have we failed to set fullscreen while the window was unmapped?
_validate_fullscreen_on_map(window_id);
XWindowAttributes xwa; XWindowAttributes xwa;
XSync(x11_display, False); XSync(x11_display, False);
XGetWindowAttributes(x11_display, wd.x11_window, &xwa); XGetWindowAttributes(x11_display, wd.x11_window, &xwa);
@@ -3671,6 +3664,9 @@ void DisplayServerX11::process_events() {
if ((xwa.map_state == IsViewable) && !wd.no_focus && !wd.is_popup) { if ((xwa.map_state == IsViewable) && !wd.no_focus && !wd.is_popup) {
XSetInputFocus(x11_display, wd.x11_window, RevertToPointerRoot, CurrentTime); XSetInputFocus(x11_display, wd.x11_window, RevertToPointerRoot, CurrentTime);
} }
// Have we failed to set fullscreen while the window was unmapped?
_validate_mode_on_map(window_id);
} break; } break;
case Expose: { case Expose: {
@@ -3690,8 +3686,7 @@ void DisplayServerX11::process_events() {
case VisibilityNotify: { case VisibilityNotify: {
DEBUG_LOG_X11("[%u] VisibilityNotify window=%lu (%u), state=%u \n", frame, event.xvisibility.window, window_id, event.xvisibility.state); DEBUG_LOG_X11("[%u] VisibilityNotify window=%lu (%u), state=%u \n", frame, event.xvisibility.window, window_id, event.xvisibility.state);
XVisibilityEvent *visibility = (XVisibilityEvent *)&event; windows[window_id].minimized = _window_minimize_check(window_id);
windows[window_id].minimized = (visibility->state == VisibilityFullyObscured);
} break; } break;
case LeaveNotify: { case LeaveNotify: {
@@ -5003,7 +4998,7 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
_window_changed(&xevent); _window_changed(&xevent);
} else if (xevent.type == MapNotify) { } else if (xevent.type == MapNotify) {
// Have we failed to set fullscreen while the window was unmapped? // Have we failed to set fullscreen while the window was unmapped?
_validate_fullscreen_on_map(main_window); _validate_mode_on_map(main_window);
} }
} }

5
platform/linuxbsd/display_server_x11.h
View File

@@ -152,6 +152,7 @@ class DisplayServerX11 : public DisplayServer {
Vector2i last_position_before_fs; Vector2i last_position_before_fs;
bool focused = true; bool focused = true;
bool minimized = false; bool minimized = false;
bool maximized = false;
bool is_popup = false; bool is_popup = false;
Rect2i parent_safe_rect; Rect2i parent_safe_rect;
@@ -268,10 +269,12 @@ class DisplayServerX11 : public DisplayServer {
void _update_real_mouse_position(const WindowData &wd); void _update_real_mouse_position(const WindowData &wd);
bool _window_maximize_check(WindowID p_window, const char *p_atom_name) const; bool _window_maximize_check(WindowID p_window, const char *p_atom_name) const;
bool _window_fullscreen_check(WindowID p_window) const; bool _window_fullscreen_check(WindowID p_window) const;
void _validate_fullscreen_on_map(WindowID p_window); bool _window_minimize_check(WindowID p_window) const;
void _validate_mode_on_map(WindowID p_window);
void _update_size_hints(WindowID p_window); void _update_size_hints(WindowID p_window);
void _set_wm_fullscreen(WindowID p_window, bool p_enabled); void _set_wm_fullscreen(WindowID p_window, bool p_enabled);
void _set_wm_maximized(WindowID p_window, bool p_enabled); void _set_wm_maximized(WindowID p_window, bool p_enabled);
void _set_wm_minimized(WindowID p_window, bool p_enabled);
void _update_context(WindowData &wd); void _update_context(WindowData &wd);