1 files changed, 227 insertions, 29 deletions

diff --git a/platform/x11/os_x11.cpp b/platform/x11/os_x11.cpp
index 240d6638a9..2d8e32137f 100644
--- a/platform/x11/os_x11.cpp
+++ b/platform/x11/os_x11.cpp
@@ -27,6 +27,7 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
+
 #include "os_x11.h"
 #include "drivers/gles3/rasterizer_gles3.h"
 #include "errno.h"
@@ -100,7 +101,7 @@ void OS_X11::initialize_core() {
 	OS_Unix::initialize_core();
 }
 
-void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
+Error OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
 
 	long im_event_mask = 0;
 	last_button_state = 0;
@@ -123,21 +124,24 @@ void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_au
 	/** XLIB INITIALIZATION **/
 	x11_display = XOpenDisplay(NULL);
 
+	if (!x11_display) {
+		ERR_PRINT("X11 Display is not available");
+		return ERR_UNAVAILABLE;
+	}
+
 	char *modifiers = NULL;
 	Bool xkb_dar = False;
-	if (x11_display) {
-		XAutoRepeatOn(x11_display);
-		xkb_dar = XkbSetDetectableAutoRepeat(x11_display, True, NULL);
+	XAutoRepeatOn(x11_display);
+	xkb_dar = XkbSetDetectableAutoRepeat(x11_display, True, NULL);
 
-		// Try to support IME if detectable auto-repeat is supported
-		if (xkb_dar == True) {
+	// Try to support IME if detectable auto-repeat is supported
+	if (xkb_dar == True) {
 
 #ifdef X_HAVE_UTF8_STRING
-			// Xutf8LookupString will be used later instead of XmbLookupString before
-			// the multibyte sequences can be converted to unicode string.
-			modifiers = XSetLocaleModifiers("");
+		// Xutf8LookupString will be used later instead of XmbLookupString before
+		// the multibyte sequences can be converted to unicode string.
+		modifiers = XSetLocaleModifiers("");
 #endif
-		}
 	}
 
 	if (modifiers == NULL) {
@@ -213,7 +217,7 @@ void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_au
 
 			XIFreeDeviceInfo(info);
 
-			if (!touch.devices.size()) {
+			if (is_stdout_verbose() && !touch.devices.size()) {
 				fprintf(stderr, "No touch devices found\n");
 			}
 		}
@@ -329,10 +333,15 @@ void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_au
 		XFree(xsh);
 	}
 
+	if (current_videomode.always_on_top) {
+		current_videomode.always_on_top = false;
+		set_window_always_on_top(true);
+	}
+
 	AudioDriverManager::initialize(p_audio_driver);
 
-	ERR_FAIL_COND(!visual_server);
-	ERR_FAIL_COND(x11_window == 0);
+	ERR_FAIL_COND_V(!visual_server, ERR_UNAVAILABLE);
+	ERR_FAIL_COND_V(x11_window == 0, ERR_UNAVAILABLE);
 
 	XSetWindowAttributes new_attr;
 
@@ -519,6 +528,8 @@ void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_au
 			_window_changed(&xevent);
 		}
 	}
+
+	return OK;
 }
 
 void OS_X11::xim_destroy_callback(::XIM im, ::XPointer client_data,
@@ -543,6 +554,21 @@ void OS_X11::set_ime_position(const Point2 &p_pos) {
 	XFree(preedit_attr);
 }
 
+String OS_X11::get_unique_id() const {
+
+	static String machine_id;
+	if (machine_id.empty()) {
+		if (FileAccess *f = FileAccess::open("/etc/machine-id", FileAccess::READ)) {
+			while (machine_id.empty() && !f->eof_reached()) {
+				machine_id = f->get_line().strip_edges();
+			}
+			f->close();
+			memdelete(f);
+		}
+	}
+	return machine_id;
+}
+
 void OS_X11::finalize() {
 
 	if (main_loop)
@@ -704,9 +730,6 @@ void OS_X11::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) con
 }
 
 void OS_X11::set_wm_fullscreen(bool p_enabled) {
-	if (current_videomode.fullscreen == p_enabled)
-		return;
-
 	if (p_enabled && !is_window_resizable()) {
 		// Set the window as resizable to prevent window managers to ignore the fullscreen state flag.
 		XSizeHints *xsh;
@@ -767,6 +790,22 @@ void OS_X11::set_wm_fullscreen(bool p_enabled) {
 	}
 }
 
+void OS_X11::set_wm_above(bool p_enabled) {
+	Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
+	Atom wm_above = XInternAtom(x11_display, "_NET_WM_STATE_ABOVE", False);
+
+	XClientMessageEvent xev;
+	memset(&xev, 0, sizeof(xev));
+	xev.type = ClientMessage;
+	xev.window = x11_window;
+	xev.message_type = wm_state;
+	xev.format = 32;
+	xev.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+	xev.data.l[1] = wm_above;
+	xev.data.l[3] = 1;
+	XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent *)&xev);
+}
+
 int OS_X11::get_screen_count() const {
 	// Using Xinerama Extension
 	int event_base, error_base;
@@ -918,6 +957,26 @@ Size2 OS_X11::get_window_size() const {
 	return Size2i(current_videomode.width, current_videomode.height);
 }
 
+Size2 OS_X11::get_real_window_size() const {
+	XWindowAttributes xwa;
+	XSync(x11_display, False);
+	XGetWindowAttributes(x11_display, x11_window, &xwa);
+	int w = xwa.width;
+	int h = xwa.height;
+	Atom prop = XInternAtom(x11_display, "_NET_FRAME_EXTENTS", True);
+	Atom type;
+	int format;
+	unsigned long len;
+	unsigned long remaining;
+	unsigned char *data = NULL;
+	if (XGetWindowProperty(x11_display, x11_window, prop, 0, 4, False, AnyPropertyType, &type, &format, &len, &remaining, &data) == Success) {
+		long *extents = (long *)data;
+		w += extents[0] + extents[1]; // left, right
+		h += extents[2] + extents[3]; // top, bottom
+	}
+	return Size2(w, h);
+}
+
 void OS_X11::set_window_size(const Size2 p_size) {
 	// If window resizable is disabled we need to update the attributes first
 	if (is_window_resizable() == false) {
@@ -941,7 +1000,19 @@ void OS_X11::set_window_size(const Size2 p_size) {
 }
 
 void OS_X11::set_window_fullscreen(bool p_enabled) {
+	if (current_videomode.fullscreen == p_enabled)
+		return;
+
+	if (p_enabled && current_videomode.always_on_top) {
+		// Fullscreen + Always-on-top requires a maximized window on some window managers (Metacity)
+		set_window_maximized(true);
+	}
 	set_wm_fullscreen(p_enabled);
+	if (!p_enabled && !current_videomode.always_on_top) {
+		// Restore
+		set_window_maximized(false);
+	}
+
 	current_videomode.fullscreen = p_enabled;
 }
 
@@ -1050,13 +1121,59 @@ void OS_X11::set_window_maximized(bool p_enabled) {
 
 	XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
 
-	while (p_enabled && !is_window_maximized()) {
-		// Wait for effective resizing (so the GLX context is too).
+	if (is_window_maximize_allowed()) {
+		while (p_enabled && !is_window_maximized()) {
+			// Wait for effective resizing (so the GLX context is too).
+		}
 	}
 
 	maximized = p_enabled;
 }
 
+bool OS_X11::is_window_maximize_allowed() {
+	Atom property = XInternAtom(x11_display, "_NET_WM_ALLOWED_ACTIONS", False);
+	Atom type;
+	int format;
+	unsigned long len;
+	unsigned long remaining;
+	unsigned char *data = NULL;
+
+	int result = XGetWindowProperty(
+			x11_display,
+			x11_window,
+			property,
+			0,
+			1024,
+			False,
+			XA_ATOM,
+			&type,
+			&format,
+			&len,
+			&remaining,
+			&data);
+
+	if (result == Success) {
+		Atom *atoms = (Atom *)data;
+		Atom wm_act_max_horz = XInternAtom(x11_display, "_NET_WM_ACTION_MAXIMIZE_HORZ", False);
+		Atom wm_act_max_vert = XInternAtom(x11_display, "_NET_WM_ACTION_MAXIMIZE_VERT", False);
+		bool found_wm_act_max_horz = false;
+		bool found_wm_act_max_vert = false;
+
+		for (unsigned int i = 0; i < len; i++) {
+			if (atoms[i] == wm_act_max_horz)
+				found_wm_act_max_horz = true;
+			if (atoms[i] == wm_act_max_vert)
+				found_wm_act_max_vert = true;
+
+			if (found_wm_act_max_horz || found_wm_act_max_vert)
+				return true;
+		}
+		XFree(atoms);
+	}
+
+	return false;
+}
+
 bool OS_X11::is_window_maximized() const {
 	// Using EWMH -- Extended Window Manager Hints
 	Atom property = XInternAtom(x11_display, "_NET_WM_STATE", False);
@@ -1102,6 +1219,27 @@ bool OS_X11::is_window_maximized() const {
 	return false;
 }
 
+void OS_X11::set_window_always_on_top(bool p_enabled) {
+	if (is_window_always_on_top() == p_enabled)
+		return;
+
+	if (p_enabled && current_videomode.fullscreen) {
+		// Fullscreen + Always-on-top requires a maximized window on some window managers (Metacity)
+		set_window_maximized(true);
+	}
+	set_wm_above(p_enabled);
+	if (!p_enabled && !current_videomode.fullscreen) {
+		// Restore
+		set_window_maximized(false);
+	}
+
+	current_videomode.always_on_top = p_enabled;
+}
+
+bool OS_X11::is_window_always_on_top() const {
+	return current_videomode.always_on_top;
+}
+
 void OS_X11::set_borderless_window(bool p_borderless) {
 
 	if (current_videomode.borderless_window == p_borderless)
@@ -1810,8 +1948,12 @@ void OS_X11::process_xevents() {
 				e = event;
 
 				req = &(e.xselectionrequest);
-				if (req->target == XA_STRING || req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) ||
-						req->target == XInternAtom(x11_display, "UTF8_STRING", 0)) {
+				if (req->target == XInternAtom(x11_display, "UTF8_STRING", 0) ||
+						req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) ||
+						req->target == XInternAtom(x11_display, "TEXT", 0) ||
+						req->target == XA_STRING ||
+						req->target == XInternAtom(x11_display, "text/plain;charset=utf-8", 0) ||
+						req->target == XInternAtom(x11_display, "text/plain", 0)) {
 					CharString clip = OS::get_clipboard().utf8();
 					XChangeProperty(x11_display,
 							req->requestor,
@@ -1824,26 +1966,40 @@ void OS_X11::process_xevents() {
 					respond.xselection.property = req->property;
 				} else if (req->target == XInternAtom(x11_display, "TARGETS", 0)) {
 
-					Atom data[2];
-					data[0] = XInternAtom(x11_display, "UTF8_STRING", 0);
-					data[1] = XA_STRING;
-					XChangeProperty(x11_display, req->requestor, req->property, req->target,
-							8, PropModeReplace, (unsigned char *)&data,
-							sizeof(data));
+					Atom data[7];
+					data[0] = XInternAtom(x11_display, "TARGETS", 0);
+					data[1] = XInternAtom(x11_display, "UTF8_STRING", 0);
+					data[2] = XInternAtom(x11_display, "COMPOUND_TEXT", 0);
+					data[3] = XInternAtom(x11_display, "TEXT", 0);
+					data[4] = XA_STRING;
+					data[5] = XInternAtom(x11_display, "text/plain;charset=utf-8", 0);
+					data[6] = XInternAtom(x11_display, "text/plain", 0);
+
+					XChangeProperty(x11_display,
+							req->requestor,
+							req->property,
+							XA_ATOM,
+							32,
+							PropModeReplace,
+							(unsigned char *)&data,
+							sizeof(data) / sizeof(data[0]));
 					respond.xselection.property = req->property;
 
 				} else {
-					printf("No String %x\n",
-							(int)req->target);
+					char *targetname = XGetAtomName(x11_display, req->target);
+					printf("No Target '%s'\n", targetname);
+					if (targetname)
+						XFree(targetname);
 					respond.xselection.property = None;
 				}
+
 				respond.xselection.type = SelectionNotify;
 				respond.xselection.display = req->display;
 				respond.xselection.requestor = req->requestor;
 				respond.xselection.selection = req->selection;
 				respond.xselection.target = req->target;
 				respond.xselection.time = req->time;
-				XSendEvent(x11_display, req->requestor, 0, 0, &respond);
+				XSendEvent(x11_display, req->requestor, True, NoEventMask, &respond);
 				XFlush(x11_display);
 			} break;
 
@@ -2205,6 +2361,48 @@ void OS_X11::set_cursor_shape(CursorShape p_shape) {
 	current_cursor = p_shape;
 }
 
+void OS_X11::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
+	if (p_cursor.is_valid()) {
+		Ref<Texture> texture = p_cursor;
+		Ref<Image> image = texture->get_data();
+
+		ERR_FAIL_COND(texture->get_width() != 32 || texture->get_height() != 32);
+
+		// Create the cursor structure
+		XcursorImage *cursor_image = XcursorImageCreate(texture->get_width(), texture->get_height());
+		XcursorUInt image_size = 32 * 32;
+		XcursorDim size = sizeof(XcursorPixel) * image_size;
+
+		cursor_image->version = 1;
+		cursor_image->size = size;
+		cursor_image->xhot = p_hotspot.x;
+		cursor_image->yhot = p_hotspot.y;
+
+		// allocate memory to contain the whole file
+		cursor_image->pixels = (XcursorPixel *)malloc(size);
+
+		image->lock();
+
+		for (XcursorPixel index = 0; index < image_size; index++) {
+			int column_index = floor(index / 32);
+			int row_index = index % 32;
+
+			*(cursor_image->pixels + index) = image->get_pixel(row_index, column_index).to_argb32();
+		}
+
+		image->unlock();
+
+		ERR_FAIL_COND(cursor_image->pixels == NULL);
+
+		// Save it for a further usage
+		cursors[p_shape] = XcursorImageLoadCursor(x11_display, cursor_image);
+
+		if (p_shape == CURSOR_ARROW) {
+			XDefineCursor(x11_display, x11_window, cursors[p_shape]);
+		}
+	}
+}
+
 void OS_X11::release_rendering_thread() {
 
 	context_gl->release_current();