From 1c175642d073689ca11b9252411ea5f8446007d0 Mon Sep 17 00:00:00 2001 From: srdusr <99972264+srdusr@users.noreply.github.com> Date: Thu, 30 May 2024 16:10:00 +0200 Subject: Fix decoration drift during animated transitions; checkpoint IPC/global-menu/output-management work Border/titlebar decoration was built from Window.geometry (the animation's final target) in both wayland backends' render loops, while sync_geometry already draws a window's actual content at window_anims' interpolated rect during any maximize/fullscreen/open-slide tween. Border and content read two different rectangles for the whole transition, so the border visibly detached from the window it was outlining - reported as "borders aren't flush." Both udev.rs and winit.rs now read the same animated rect for titlebar placement, border-strip placement, and the occlusion test against later windows in stacking order. Verified: cargo build --workspace, cargo clippy (0 new warnings), cargo test -p srdwm-core (111/111). Also checkpoints substantial protocol/IPC work from prior sessions that had accumulated uncommitted: gtk-shell1 support (gtk_shell.rs, the vendored gtk-shell.xml, xwayland.rs's X11-side mirror) backing the global app menu; zwlr_foreign_toplevel_manager_v1 (foreign_toplevel.rs) broadcasting distinct maximized/minimized/fullscreen/activated state per window; output_management (ext-output-management + layer-shell exclusive-zone reservation tracking); workspace.rs and context_menu.rs; a Unix-socket IPC crate (platform/src/ ipc.rs) and a `srd` control-CLI crate (crates/ctl); xkb_config.rs; and a theme module (core/src/theme.rs). A peer session working the AGS shell concurrently verified several of these live against a running srdwm: the global menu rendering a real app's File/Edit menu over gtk-shell1, and foreign-toplevel correctly reporting maximized and fullscreen as independent, non-simultaneous states with the geometry each implies (maximize stops at a reserved top bar and past a dock; fullscreen reaches the true monitor edge). --- crates/wayland/src/gtk_shell.rs | 116 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 crates/wayland/src/gtk_shell.rs (limited to 'crates/wayland/src/gtk_shell.rs') diff --git a/crates/wayland/src/gtk_shell.rs b/crates/wayland/src/gtk_shell.rs new file mode 100644 index 0000000..f4ae030 --- /dev/null +++ b/crates/wayland/src/gtk_shell.rs @@ -0,0 +1,116 @@ +//! `gtk_shell1`/`gtk_surface1`: the Wayland-native half of global-menu +//! support - see `srdwm_core::GlobalMenu`'s doc comment and `xwayland.rs`'s +//! `EwmhState::read_global_menu` for the XWayland half and the full +//! rationale (carry the D-Bus *address*, never the menu content itself). +//! +//! GTK4 only calls `gtk_surface1.set_dbus_properties` - the one request +//! this module actually needs - once it knows the compositor supports the +//! protocol at all, which it establishes by binding `gtk_shell1` and +//! getting a `capabilities` event back. Everything else in the protocol +//! (startup-notification IDs, tiled-state events, modal hints, the +//! titlebar-gesture request GNOME Shell uses for its own double/right/ +//! middle-click-titlebar handling) is real but out of scope for what this +//! pass is actually for - acknowledged with a no-op rather than silently +//! ignored, so a future pass extending this has a clear list of what was +//! deliberately left alone. + +use smithay::reexports::wayland_server::backend::GlobalId; +use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface; +use smithay::reexports::wayland_server::{Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New}; + +use crate::gtk_shell_protocol::server::gtk_shell1::{self, GtkShell1}; +use crate::gtk_shell_protocol::server::gtk_surface1::{self, GtkSurface1}; +use crate::state::CompState; + +const PROTOCOL_VERSION: u32 = 7; + +/// `global_app_menu | global_menu_bar` - both bits set unconditionally. +/// srdwm has no reason to advertise one without the other: both map onto +/// the same `GlobalMenu`, just the app-menu-only fallback for a client +/// that never got around to exporting a real menu bar. +const CAPABILITIES: u32 = 0b011; + +pub struct GtkShellState { + _global: GlobalId, +} + +impl GtkShellState { + pub fn new(dh: &DisplayHandle) -> Self + where + D: GlobalDispatch + 'static, + { + Self { _global: dh.create_global::(PROTOCOL_VERSION, ()) } + } +} + +/// The `wl_surface` a `gtk_surface1` was created for - the only thing +/// `set_dbus_properties` needs to know which `WindowId` to attach its +/// payload to. +pub struct GtkSurfaceData { + surface: WlSurface, +} + +impl GlobalDispatch for CompState { + fn bind(_state: &mut CompState, _dh: &DisplayHandle, _client: &Client, resource: New, _global_data: &(), data_init: &mut DataInit<'_, CompState>) { + let shell = data_init.init(resource, ()); + // Sent once, right after bind - see this module's doc comment for + // why this has to happen unprompted rather than waiting to be + // asked: GTK only bothers calling `set_dbus_properties` later if it + // saw this first. + shell.capabilities(CAPABILITIES); + } +} + +impl Dispatch for CompState { + fn request(state: &mut CompState, _client: &Client, _resource: &GtkShell1, request: gtk_shell1::Request, _data: &(), _dh: &DisplayHandle, data_init: &mut DataInit<'_, CompState>) { + if let gtk_shell1::Request::GetGtkSurface { gtk_surface, surface } = request { + data_init.init(gtk_surface, GtkSurfaceData { surface }); + } + // `set_startup_id`/`system_bell`/`notify_launch`: no startup- + // notification or accessibility-bell feature exists to wire these + // into yet - see this module's doc comment. + let _ = state; + } +} + +impl Dispatch for CompState { + fn request(state: &mut CompState, _client: &Client, _resource: &GtkSurface1, request: gtk_surface1::Request, data: &GtkSurfaceData, _dh: &DisplayHandle, _data_init: &mut DataInit<'_, CompState>) { + let gtk_surface1::Request::SetDbusProperties { menubar_path, app_menu_path, window_object_path, application_object_path, unique_bus_name, .. } = request else { + // `set_modal`/`unset_modal`/`present`/`request_focus`/`release`/ + // `titlebar_gesture`/`set_a11y_properties`: real requests, none + // of which this pass has a feature behind yet. + return; + }; + let Some(&id) = state.surface_to_id.get(&data.surface) else { return }; + // A `None`/empty bus name means the client is *clearing* its menu + // (or never had one) - matches `xwayland.rs`'s `read_global_menu` + // returning `None` for the same case, so a panel sees the same + // shape regardless of which backend a window came from. + // Always `MenuSource::Gtk`: this protocol has no Unity-style + // equivalent to carry, unlike XWayland's `_UNITY_OBJECT_PATH` -- + // see `xwayland.rs`'s `read_global_menu` for the case that needs + // the other variant. + let menu = unique_bus_name.filter(|s| !s.is_empty()).map(|bus_name| srdwm_core::GlobalMenu { + bus_name, + menu_path: menubar_path.filter(|s| !s.is_empty()).or_else(|| app_menu_path.filter(|s| !s.is_empty())), + app_path: application_object_path.filter(|s| !s.is_empty()), + window_path: window_object_path.filter(|s| !s.is_empty()), + source: srdwm_core::MenuSource::Gtk, + }); + if let Some(w) = state.wm.borrow_mut().window_mut(id) { + w.global_menu = menu; + } + } + + fn destroyed(state: &mut CompState, _client: smithay::reexports::wayland_server::backend::ClientId, _resource: &GtkSurface1, data: &GtkSurfaceData) { + // The surface itself may already be gone (this fires on the normal + // window-close teardown path too, not just an explicit `release`) + // - `surface_to_id` simply won't resolve in that case, same as + // any other post-close lookup elsewhere in this codebase. + if let Some(&id) = state.surface_to_id.get(&data.surface) { + if let Some(w) = state.wm.borrow_mut().window_mut(id) { + w.global_menu = None; + } + } + } +} -- cgit v1.2.3