Read X11 always-on-top/bottom from _NET_WM_STATE

GDK never reports the above/below states it requests on X11, so
IsAlwaysOnTop() and IsAlwaysOnBottom() were always false there even though
the window manager had applied them (seen with xprop under GNOME's
Xwayland). Read _NET_WM_STATE directly, and refresh the reported
properties on its PropertyNotify so WindowPropertyChangedEvent follows.
Wayland keeps GDK's state.

The property test now probes keep-above through the public getter; on
GNOME/Xwayland (Mutter) all always-on-top checks run and pass.

Author: lijy91

src/platform/linux/window_linux.cpp

@@ -770,6 +770,33 @@ class Window::Impl {
   Size requested_content_size_ = {0, 0};
 };
 
+#ifdef GDK_WINDOWING_X11
+// Whether the window manager lists |state| (an atom name such as
+// "_NET_WM_STATE_ABOVE") in the window's _NET_WM_STATE. GDK does not track the
+// above/below states it requests, so its window state never shows them.
+static bool HasX11WindowState(GdkWindow* surface, const char* state) {
+  auto* display = gdk_window_get_display(surface);
+  auto* xdisplay = GDK_DISPLAY_XDISPLAY(display);
+  const Atom wanted = gdk_x11_get_xatom_by_name_for_display(display, state);
+  Atom type = 0;
+  int format = 0;
+  unsigned long count = 0, remaining = 0;
+  unsigned char* data = nullptr;
+  bool found = false;
+  gdk_x11_display_error_trap_push(display);
+  if (XGetWindowProperty(xdisplay, GDK_WINDOW_XID(surface),
+                         gdk_x11_get_xatom_by_name_for_display(display, "_NET_WM_STATE"), 0, 64,
+                         False, XA_ATOM, &type, &format, &count, &remaining, &data) == Success &&
+      data && type == XA_ATOM && format == 32) {
+    const auto* atoms = reinterpret_cast<Atom*>(data);
+    for (unsigned long i = 0; i < count && !found; ++i) found = atoms[i] == wanted;
+  }
+  if (data) XFree(data);
+  gdk_x11_display_error_trap_pop_ignored(display);
+  return found;
+}
+#endif
+
 // Reports direct changes to the properties WindowPropertyChangedEvent covers:
 // the GtkWindow's title, resizable and deletable properties, and the window
 // manager's above/below state. The handlers sit on the widget itself, so GTK
@@ -807,6 +834,23 @@ static bool ObserveWindowProperties(GtkWidget* widget) {
                            return FALSE;
                          }),
                          nullptr);
+#ifdef GDK_WINDOWING_X11
+  // The above/below states only show in _NET_WM_STATE (see HasX11WindowState).
+  if (auto* surface = gtk_widget_get_window(widget); surface && GDK_IS_X11_WINDOW(surface)) {
+    gdk_window_add_filter(
+        surface,
+        +[](GdkXEvent* native, GdkEvent*, gpointer data) -> GdkFilterReturn {
+          auto* event = static_cast<XEvent*>(native);
+          auto* self = static_cast<GtkWidget*>(data);
+          if (event->type == PropertyNotify &&
+              event->xproperty.atom == gdk_x11_get_xatom_by_name_for_display(
+                                           gtk_widget_get_display(self), "_NET_WM_STATE"))
+            RefreshPropertiesOf(self);
+          return GDK_FILTER_CONTINUE;
+        },
+        widget);
+  }
+#endif
   // Occlusion: shown and hidden (minimizing is the window-state-event above).
   auto on_mapping = +[](GtkWidget* self, gpointer) { RefreshOcclusionOf(self); };
   g_signal_connect_after(widget, "map", G_CALLBACK(on_mapping), nullptr);
@@ -1542,6 +1586,10 @@ void Window::SetAlwaysOnTop(bool is_always_on_top) {
 bool Window::IsAlwaysOnTop() const {
   if (!pimpl_->gdk_window_)
     return false;
+#ifdef GDK_WINDOWING_X11
+  if (GDK_IS_X11_WINDOW(pimpl_->gdk_window_))
+    return HasX11WindowState(pimpl_->gdk_window_, "_NET_WM_STATE_ABOVE");
+#endif
   GdkWindowState state = gdk_window_get_state(pimpl_->gdk_window_);
   return state & GDK_WINDOW_STATE_ABOVE;
 }
@@ -1558,6 +1606,10 @@ void Window::SetAlwaysOnBottom(bool is_always_on_bottom) {
 bool Window::IsAlwaysOnBottom() const {
   if (!pimpl_->gdk_window_)
     return false;
+#ifdef GDK_WINDOWING_X11
+  if (GDK_IS_X11_WINDOW(pimpl_->gdk_window_))
+    return HasX11WindowState(pimpl_->gdk_window_, "_NET_WM_STATE_BELOW");
+#endif
   GdkWindowState state = gdk_window_get_state(pimpl_->gdk_window_);
   return state & GDK_WINDOW_STATE_BELOW;
 }

tests/window_property_changed_test.cpp

@@ -74,18 +74,19 @@ int main(int argc, char** argv) {
 #endif
   Pump([] { return false; }, 300);  // Linux subscribes on the next main loop turn.
 
-  // GTK reports keep-above only once the window manager confirms it, which
-  // not every one does (Openbox on Xvfb does not); check with a plain window.
+  // Keep-above is up to the window manager (Wayland has none for clients);
+  // check with a separate shown window whether this one honors it.
   bool keep_above_confirmed = true;
 #if !defined(__APPLE__) && !defined(_WIN32)
   {
-    GtkWidget* plain = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-    gtk_widget_show(plain);
+    Window probe;
+    probe.Show();
     Pump([] { return false; }, 300);
-    gtk_window_set_keep_above(GTK_WINDOW(plain), TRUE);
-    Pump([&] { return !!(gdk_window_get_state(gtk_widget_get_window(plain)) & GDK_WINDOW_STATE_ABOVE); });
-    keep_above_confirmed = gdk_window_get_state(gtk_widget_get_window(plain)) & GDK_WINDOW_STATE_ABOVE;
-    gtk_widget_destroy(plain);
+    probe.SetAlwaysOnTop(true);
+    Pump([&] { return probe.IsAlwaysOnTop(); });
+    keep_above_confirmed = probe.IsAlwaysOnTop();
+    gtk_widget_destroy(GTK_WIDGET(probe.GetNativeObject()));
+    Pump([] { return false; }, 100);
     if (!keep_above_confirmed)
       std::cout << "SKIP always-on-top: the window manager does not confirm keep-above" << std::endl;
   }