Add global-menu support (dbusmenu/appmenu) for Wayland and X11 clients

Exposes each window's application menu (Firefox/GTK's dbusmenu export,
X11's _GTK_APPLICATION_OBJECT_PATH-style menus via global_menu.rs) so
an external panel can render it as a system menu bar rather than each
window drawing its own, the same convention appmenu.rs/gtk_shell.rs
and appmenu_registrar.rs wire up across both backends.

1 files changed, 90 insertions, 0 deletions

diff --git a/crates/x11/src/platform/global_menu.rs b/crates/x11/src/platform/global_menu.rs
new file mode 100644
index 0000000..161fe80
--- /dev/null
+++ b/crates/x11/src/platform/global_menu.rs
@@ -0,0 +1,90 @@
+//! Global-menu support for the native X11 backend - parity with the
+//! Wayland backend's XWayland integration (`crates/wayland/src/xwayland.rs`
+//! and `srdwm_platform::appmenu_registrar`), reading the identical X11
+//! properties and running the identical `com.canonical.AppMenu.Registrar`
+//! D-Bus service, since a client-side toolkit (GTK/Qt) exports its menu the
+//! same way regardless of which X server it's actually talking to.
+
+use super::*;
+
+impl X11Platform {
+    /// Reads `xid`'s global-menu D-Bus address straight off its own X11
+    /// properties - `_GTK_UNIQUE_BUS_NAME` plus whichever menu-path atom
+    /// the client actually set. Exact mirror of `crates/wayland/src/
+    /// xwayland.rs::EwmhState::read_global_menu`; see that method's doc
+    /// comment for the full reasoning (menubar wins over app-menu, the
+    /// `appmenu-gtk-module` Unity-shim case `classify_menu_source` exists
+    /// for). No bus name means no menu at all, so this returns `None`
+    /// rather than a `GlobalMenu` with an empty `bus_name`.
+    pub(super) fn read_global_menu(&self, xid: XWindow) -> Option<srdwm_core::GlobalMenu> {
+        let read_string = |atom: u32| -> Option<String> {
+            let reply = self.conn.get_property(false, xid, atom, x11rb::protocol::xproto::AtomEnum::ANY, 0, u32::MAX).ok()?.reply().ok()?;
+            if reply.value.is_empty() {
+                return None;
+            }
+            String::from_utf8(reply.value).ok().filter(|s| !s.is_empty())
+        };
+
+        // Checked before anything GTK-atom-related - see `xwayland.rs`'s
+        // identical check in its own `read_global_menu` for why: these two
+        // are already a complete address on their own, and a Qt app under
+        // a KDE Plasma session never sets `_GTK_UNIQUE_BUS_NAME` at all.
+        if let (Some(bus_name), Some(menu_path)) = (read_string(self.atoms._KDE_NET_WM_APPMENU_SERVICE_NAME), read_string(self.atoms._KDE_NET_WM_APPMENU_OBJECT_PATH)) {
+            return Some(srdwm_core::GlobalMenu { bus_name, menu_path: Some(menu_path), app_path: None, window_path: None, source: srdwm_core::MenuSource::DbusMenu });
+        }
+
+        let bus_name = read_string(self.atoms._GTK_UNIQUE_BUS_NAME)?;
+        let app_path = read_string(self.atoms._GTK_APPLICATION_OBJECT_PATH);
+        let window_path = read_string(self.atoms._GTK_WINDOW_OBJECT_PATH);
+        let is_real_gtk_application = app_path.is_some() || window_path.is_some();
+        let gtk_menu_path = read_string(self.atoms._GTK_MENUBAR_OBJECT_PATH).or_else(|| read_string(self.atoms._GTK_APP_MENU_OBJECT_PATH));
+        let unity_path = read_string(self.atoms._UNITY_OBJECT_PATH);
+        let (menu_path, source) = srdwm_core::classify_menu_source(gtk_menu_path, is_real_gtk_application, unity_path);
+        Some(srdwm_core::GlobalMenu { bus_name, menu_path, app_path, window_path, source })
+    }
+
+    /// Refreshes the focused window's `global_menu` from its own X11
+    /// properties - call on every real focus change (`Platform::focus`,
+    /// the single chokepoint every focus path already goes through, same
+    /// role `update_net_active_window` plays for the Wayland backend).
+    /// Global-menu properties are usually set once, shortly after a client
+    /// registers on the session bus, which can race a window's own initial
+    /// map - reading only at map time would miss a client that finished
+    /// registering a moment later, so this re-reads on every focus instead.
+    /// `read_global_menu` returning `None` (the common case for anything
+    /// non-GTK, or a GTK app with no menu to export) correctly clears a
+    /// stale value left over from whichever window was focused before.
+    pub(super) fn refresh_focused_global_menu(&mut self, id: WindowId, client: XWindow) {
+        let menu = self.read_global_menu(client);
+        if let Some(w) = self.wm.borrow_mut().window_mut(id) {
+            w.global_menu = menu;
+        }
+    }
+
+    /// Drains `AppmenuRegistrarState`'s channel and applies every event to
+    /// the matching `Window.global_menu` - call once per `poll_events`
+    /// tick, same as the Wayland backend's `xwayland.rs::apply_registrar_
+    /// events`. `xid_to_core` already maps XID straight to `WindowId` here
+    /// (unlike the Wayland backend, which has to scan for the matching
+    /// `X11Surface`), so this needs no extra lookup structure of its own.
+    pub(super) fn apply_registrar_events(&mut self) {
+        let Some(registrar) = &self.appmenu_registrar else { return };
+        let events = registrar.drain_events();
+        if events.is_empty() {
+            return;
+        }
+        for event in events {
+            let (window_id, menu) = match event {
+                srdwm_platform::RegistrarEvent::Registered { window_id, bus_name, menu_path } => (
+                    window_id,
+                    Some(srdwm_core::GlobalMenu { bus_name, menu_path: Some(menu_path), app_path: None, window_path: None, source: srdwm_core::MenuSource::DbusMenu }),
+                ),
+                srdwm_platform::RegistrarEvent::Unregistered { window_id } => (window_id, None),
+            };
+            let Some(&id) = self.xid_to_core.get(&window_id) else { continue };
+            if let Some(w) = self.wm.borrow_mut().window_mut(id) {
+                w.global_menu = menu;
+            }
+        }
+    }
+}