[GTK] Anchor Wayland display coordinates to the monitor of the window

Wayland never tells a client where its window is, so gdk_window_get_origin
returns window relative values while Monitor geometry is global. Code that
clips a location against a monitor then mixes two coordinate spaces.

The JFace information controls do exactly that. With a monitor layout whose
client areas do not start near y=0, every anchor is rejected: hovers come up
empty and the content assist javadoc popup lands on a different monitor.

Wayland does report which monitor a surface is on. Anchor display coordinates
to that origin, and remove it again when positioning a window or a menu.
Display.getCursorLocation() gets the same treatment, since callers compare it
against Control.toDisplay().

The window's position within its monitor is still unknown. Popups are placed
relative to their parent and unaffected by that remaining error.

X11 and GTK4 are unchanged.

Fixes #3539

Author: vogella

bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Control.java

@@ -1691,8 +1691,9 @@ public Point toControl(int x, int y) {
 		origin_x[0] = origin.x;
 		origin_y[0] = origin.y;
 	} else {
-		long window = eventWindow();
-		GDK.gdk_window_get_origin(window, origin_x, origin_y);
+		Point origin = getWindowOrigin();
+		origin_x[0] = origin.x;
+		origin_y[0] = origin.y;
 	}
 
 	x -= origin_x[0];
@@ -1756,8 +1757,9 @@ public Point toDisplay(int x, int y) {
 		origin_x[0] = origin.x;
 		origin_y[0] = origin.y;
 	} else {
-		long window = eventWindow();
-		GDK.gdk_window_get_origin(window, origin_x, origin_y);
+		Point origin = getWindowOrigin();
+		origin_x[0] = origin.x;
+		origin_y[0] = origin.y;
 	}
 
 	if ((style & SWT.MIRRORED) != 0) x = getClientWidth() - x;
@@ -6919,9 +6921,39 @@ Point getWindowOrigin () {
 	long window = eventWindow ();
 	GDK.gdk_window_get_origin (window, x, y);
 
+	Point monitorOrigin = monitorOrigin ();
+	if (monitorOrigin != null) {
+		x [0] += monitorOrigin.x;
+		y [0] += monitorOrigin.y;
+	}
+
 	return new Point (x [0], y [0]);
 }
 
+/**
+ * Offset that maps window relative GDK coordinates into the space of the monitor showing the
+ * receiver, or <code>null</code> when none is needed. Wayland reports no global position, so
+ * without it {@link Monitor} geometry and control coordinates cannot be compared.
+ */
+Point monitorOrigin () {
+	if (GTK.GTK4 || !OS.isWayland ()) return null;
+	long displayHandle = GDK.gdk_display_get_default ();
+	if (displayHandle == 0) return null;
+	// An unmapped Shell has no GdkWindow; the nearest ancestor that has one is on the same monitor.
+	long window = 0;
+	for (Control control = this; control != null; control = control.parent) {
+		window = gtk_widget_get_window (control.getShell ().topHandle ());
+		if (window != 0) break;
+	}
+	if (window == 0) return null;
+	long monitor = GDK.gdk_display_get_monitor_at_window (displayHandle, window);
+	if (monitor == 0) return null;
+	GdkRectangle geometry = new GdkRectangle ();
+	GDK.gdk_monitor_get_geometry (monitor, geometry);
+	if (geometry.x == 0 && geometry.y == 0) return null;
+	return new Point (geometry.x, geometry.y);
+}
+
 /**
  * Gets the position of the top left corner of the control in root window (display) coordinates.
  * GTK4 only, do not call on GTK3.

bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Display.java

@@ -2045,6 +2045,8 @@ public Point getCursorLocation() {
 				y[0]+= offsetY[0];
 				tempShell = tempShell.getParent().getShell();
 			}
+			// Callers compare this against Control.toDisplay(), so use the same space.
+			tempShell.applyMonitorOrigin (x, y);
 		}
 	}
 

bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Menu.java

@@ -447,8 +447,12 @@ void _setVisible (boolean visible) {
 						GTK3.memmove (eventPtr, event, GdkEventButton.sizeof);
 						// Bug in GTK?: testing with SWT_MENU_LOCATION_DEBUGGING=1 shows final_rect.x and
 						// final_rect.y popup menu position is off by 1 compared to this.x and this.y
-						rect.x = this.x + 1;
-						rect.y = this.y + 1;
+						// The rectangle is relative to the shell, so the monitor origin has to go.
+						Point monitorOrigin = getShell ().monitorOrigin ();
+						int originX = monitorOrigin != null ? monitorOrigin.x : 0;
+						int originY = monitorOrigin != null ? monitorOrigin.y : 0;
+						rect.x = this.x + 1 - originX;
+						rect.y = this.y + 1 - originY;
 					}
 					// Popup the menu and pin it at the top left corner of the GdkRectangle relative to the GdkWindow
 					GTK3.gtk_menu_popup_at_rect(handle, event.window, rect, GDK.GDK_GRAVITY_NORTH_WEST,

bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Shell.java

@@ -1348,10 +1348,26 @@ public Point getLocation() {
 		// TODO: GTK4 GtkWindow no longer has the ability to get position
 	} else {
 		GTK3.gtk_window_get_position (shellHandle, x, y);
+		applyMonitorOrigin (x, y);
 	}
 	return new Point (x [0], y [0]);
 }
 
+@Override
+Point monitorOrigin () {
+	// A child Shell is positioned while still hidden, before its own monitor is known.
+	if (parent != null) return parent.monitorOrigin ();
+	return super.monitorOrigin ();
+}
+
+/** Shifts a window relative GTK position into display coordinates. */
+void applyMonitorOrigin (int [] x, int [] y) {
+	Point origin = monitorOrigin ();
+	if (origin == null) return;
+	x [0] += origin.x;
+	y [0] += origin.y;
+}
+
 @Override
 public boolean getMaximized () {
 	checkWidget();
@@ -1601,6 +1617,7 @@ long gtk3_button_press_event (long widget, long event) {
 long gtk_configure_event (long widget, long event) {
 	int [] x = new int [1], y = new int [1];
 	GTK3.gtk_window_get_position (shellHandle, x, y);
+	applyMonitorOrigin (x, y);
 
 	if (!isVisible ()) {
 		return 0; //We shouldn't handle move/resize events if shell is hidden.
@@ -2417,9 +2434,13 @@ int setBounds (int x, int y, int width, int height, boolean move, boolean resize
 			}
 			if (mapped) positionPopover();
 		} else if (!GTK.GTK4) {
+			// GTK positions windows in its own space; x and y arrive in display coordinates.
+			Point origin = monitorOrigin ();
+			int gtkX = origin != null ? x - origin.x : x;
+			int gtkY = origin != null ? y - origin.y : y;
 			int [] x_pos = new int [1], y_pos = new int [1];
 			GTK3.gtk_window_get_position(shellHandle, x_pos, y_pos);
-			GTK3.gtk_window_move(shellHandle, x, y);
+			GTK3.gtk_window_move(shellHandle, gtkX, gtkY);
 			/*
 			 * Bug in GTK: gtk_window_get_position () is not always up-to-date right after
 			 * gtk_window_move (). The random delays cause problems like bug 445900.
@@ -2431,11 +2452,11 @@ int setBounds (int x, int y, int width, int height, boolean move, boolean resize
 			for (int i = 0; i < 1000; i++) {
 				int [] x2_pos = new int [1], y2_pos = new int [1];
 				GTK3.gtk_window_get_position(shellHandle, x2_pos, y2_pos);
-				if (x2_pos[0] == x && y2_pos[0] == y) {
+				if (x2_pos[0] == gtkX && y2_pos[0] == gtkY) {
 					break;
 				}
 			}
-			if (x_pos [0] != x || y_pos [0] != y) {
+			if (x_pos [0] != gtkX || y_pos [0] != gtkY) {
 				moved = true;
 				oldX = x;
 				oldY = y;
@@ -3613,6 +3634,7 @@ Rectangle getBoundsInPixels () {
 			GDK.gdk_window_get_root_origin(GTK3.gtk_widget_get_window(shellHandle), x, y);
 		}
 	}
+	if (!GTK.GTK4) applyMonitorOrigin (x, y);
 	GtkAllocation allocation = new GtkAllocation ();
 	GTK.gtk_widget_get_allocation (vboxHandle, allocation);
 	int width = allocation.width;