// SPDX-FileCopyrightText: © 2020 The River Developers
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::ffi;
 use crate::server::{Server, WlListener, WlList, wl_listener_remove, wl_signal_add};
 use crate::window::Window;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ConfigureState {
     Idle,
     Inflight(u32),
     Acked,
     Committed,
     TimedOut(u32),
     TimedOutAcked,
 }
 
 pub struct XdgToplevel {
     pub window: *mut Window,
     pub wlr_toplevel: *mut ffi::wlr_xdg_toplevel,
     pub decoration: *mut XdgDecoration,
     pub geometry: ffi::wlr_box,
     /// Surface extent as of the last commit — with `geometry`, the mapping
     /// change detector for the deferred pointer refresh (see `handle_commit`).
     pub last_surface_size: (i32, i32),
     pub configure_state: ConfigureState,
     /// Has the client ever answered a configure? Until it has,
     /// `geometry` is the size the CLIENT asked for, not a response to one
     /// — see `Window::render_start`, which refuses to adopt a wish over a
     /// restored size.
     pub acked_once: bool,
 
     pub destroy: ffi::wl_listener,
     pub ack_configure: ffi::wl_listener,
     pub map: ffi::wl_listener,
     pub unmap: ffi::wl_listener,
     pub commit: ffi::wl_listener,
     pub new_popup: ffi::wl_listener,
     pub request_show_window_menu: ffi::wl_listener,
     pub request_fullscreen: ffi::wl_listener,
     pub request_maximize: ffi::wl_listener,
     pub request_minimize: ffi::wl_listener,
     pub request_move: ffi::wl_listener,
     pub request_resize: ffi::wl_listener,
     pub set_parent: ffi::wl_listener,
     pub set_title: ffi::wl_listener,
     pub set_app_id: ffi::wl_listener,
 }
 
 pub struct XdgDecoration {
     pub wlr_decoration: *mut ffi::wlr_xdg_toplevel_decoration_v1,
     pub destroy: ffi::wl_listener,
     pub request_mode: ffi::wl_listener,
 }
 
 impl XdgToplevel {
     pub unsafe fn create(
         wlr_toplevel: *mut ffi::wlr_xdg_toplevel,
         server: *mut Server,
     ) -> Result<(), &'static str> {
         log::debug!("new xdg_toplevel");
 
         let window = Window::create(crate::window::WindowImpl::Toplevel(std::ptr::null_mut()), server)?;
 
         let toplevel = Box::new(XdgToplevel {
             window,
             wlr_toplevel,
             decoration: std::ptr::null_mut(),
             geometry: std::mem::zeroed(),
             last_surface_size: (0, 0),
             configure_state: ConfigureState::Idle,
             acked_once: false,
 
             destroy: std::mem::zeroed(),
             ack_configure: std::mem::zeroed(),
             map: std::mem::zeroed(),
             unmap: std::mem::zeroed(),
             commit: std::mem::zeroed(),
             new_popup: std::mem::zeroed(),
             request_show_window_menu: std::mem::zeroed(),
             request_fullscreen: std::mem::zeroed(),
             request_maximize: std::mem::zeroed(),
             request_minimize: std::mem::zeroed(),
             request_move: std::mem::zeroed(),
             request_resize: std::mem::zeroed(),
             set_parent: std::mem::zeroed(),
             set_title: std::mem::zeroed(),
             set_app_id: std::mem::zeroed(),
         });
 
         let raw = Box::into_raw(toplevel);
         (*window).set_impl(crate::window::WindowImpl::Toplevel(raw));
 
         let base = ffi::river_wlr_xdg_toplevel_get_base(wlr_toplevel);
         let surface = ffi::river_wlr_xdg_surface_get_surface(base);
 
         let unmap_listener = &mut (*raw).unmap as *mut ffi::wl_listener as *mut WlListener;
         (*unmap_listener).notify = Some(handle_unmap);
         wl_signal_add(ffi::river_wlr_surface_get_unmap_signal(surface), &mut (*raw).unmap);
 
         let surfaces_tree = (*window).surfaces.tree;
         let capture_tree = &mut (*(*window).capture_scene).tree as *mut ffi::wlr_scene_tree;
 
         let scene_xdg = ffi::wlr_scene_xdg_surface_create(surfaces_tree, base);
         if scene_xdg.is_null() {
             let _ = Box::from_raw(raw);
             return Err("wlr_scene_xdg_surface_create failed");
         }
         let capture_xdg = ffi::wlr_scene_xdg_surface_create(capture_tree, base);
         if capture_xdg.is_null() {
             // Already added unmap listener, but let's at least try to free raw
             let _ = Box::from_raw(raw);
             return Err("wlr_scene_xdg_surface_create for capture tree failed");
         }
 
         ffi::river_wlr_xdg_surface_set_data(base, raw as *mut _);
         ffi::river_wlr_surface_set_data(surface, (*window).tree as *mut ffi::wlr_scene_node as *mut _);
 
         let destroy_listener = &mut (*raw).destroy as *mut ffi::wl_listener as *mut WlListener;
         (*destroy_listener).notify = Some(handle_destroy);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_destroy_signal(wlr_toplevel), &mut (*raw).destroy);
 
         let ack_listener = &mut (*raw).ack_configure as *mut ffi::wl_listener as *mut WlListener;
         (*ack_listener).notify = Some(handle_ack_configure);
         wl_signal_add(ffi::river_wlr_xdg_surface_get_ack_configure_signal(base), &mut (*raw).ack_configure);
 
         let map_listener = &mut (*raw).map as *mut ffi::wl_listener as *mut WlListener;
         (*map_listener).notify = Some(handle_map);
         wl_signal_add(ffi::river_wlr_surface_get_map_signal(surface), &mut (*raw).map);
 
         let commit_listener = &mut (*raw).commit as *mut ffi::wl_listener as *mut WlListener;
         (*commit_listener).notify = Some(handle_commit);
         wl_signal_add(ffi::river_wlr_surface_get_commit_signal(surface), &mut (*raw).commit);
 
         let popup_listener = &mut (*raw).new_popup as *mut ffi::wl_listener as *mut WlListener;
         (*popup_listener).notify = Some(handle_new_popup);
         wl_signal_add(ffi::river_wlr_xdg_surface_get_new_popup_signal(base), &mut (*raw).new_popup);
 
         let menu_listener = &mut (*raw).request_show_window_menu as *mut ffi::wl_listener as *mut WlListener;
         (*menu_listener).notify = Some(handle_request_show_window_menu);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_show_window_menu_signal(wlr_toplevel), &mut (*raw).request_show_window_menu);
 
         let fs_listener = &mut (*raw).request_fullscreen as *mut ffi::wl_listener as *mut WlListener;
         (*fs_listener).notify = Some(handle_request_fullscreen);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_fullscreen_signal(wlr_toplevel), &mut (*raw).request_fullscreen);
 
         let max_listener = &mut (*raw).request_maximize as *mut ffi::wl_listener as *mut WlListener;
         (*max_listener).notify = Some(handle_request_maximize);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_maximize_signal(wlr_toplevel), &mut (*raw).request_maximize);
 
         let min_listener = &mut (*raw).request_minimize as *mut ffi::wl_listener as *mut WlListener;
         (*min_listener).notify = Some(handle_request_minimize);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_minimize_signal(wlr_toplevel), &mut (*raw).request_minimize);
 
         let move_listener = &mut (*raw).request_move as *mut ffi::wl_listener as *mut WlListener;
         (*move_listener).notify = Some(handle_request_move);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_move_signal(wlr_toplevel), &mut (*raw).request_move);
 
         let resize_listener = &mut (*raw).request_resize as *mut ffi::wl_listener as *mut WlListener;
         (*resize_listener).notify = Some(handle_request_resize);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_request_resize_signal(wlr_toplevel), &mut (*raw).request_resize);
 
         let parent_listener = &mut (*raw).set_parent as *mut ffi::wl_listener as *mut WlListener;
         (*parent_listener).notify = Some(handle_set_parent);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_set_parent_signal(wlr_toplevel), &mut (*raw).set_parent);
 
         let title_listener = &mut (*raw).set_title as *mut ffi::wl_listener as *mut WlListener;
         (*title_listener).notify = Some(handle_set_title);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_set_title_signal(wlr_toplevel), &mut (*raw).set_title);
 
         let app_listener = &mut (*raw).set_app_id as *mut ffi::wl_listener as *mut WlListener;
         (*app_listener).notify = Some(handle_set_app_id);
         wl_signal_add(ffi::river_wlr_xdg_toplevel_get_set_app_id_signal(wlr_toplevel), &mut (*raw).set_app_id);
 
         Ok(())
     }
 
     pub unsafe fn destroy_popups(&self) {
         let base = ffi::river_wlr_xdg_toplevel_get_base(self.wlr_toplevel);
         let list_head = ffi::river_wlr_xdg_surface_get_popups(base) as *mut WlList;
         let mut curr = (*list_head).next;
         while curr != list_head {
             let next = (*curr).next;
             let popup = crate::container_of!(curr, ffi::wlr_xdg_popup, link);
             ffi::wl_resource_destroy((*popup).resource);
             curr = next;
         }
     }
 
     pub unsafe fn configure(&mut self) -> bool {
         match self.configure_state {
             ConfigureState::Idle
             | ConfigureState::Inflight(..)
             | ConfigureState::Acked
             | ConfigureState::Committed
             | ConfigureState::TimedOut(..)
             | ConfigureState::TimedOutAcked => {}
         }
 
         let scheduled = &(*self.window).configure_scheduled;
         let sent = &(*self.window).configure_sent;
 
         if !self.needs_configure() {
             match self.configure_state {
                 ConfigureState::Idle => return false,
                 ConfigureState::TimedOut(serial) => {
                     self.configure_state = ConfigureState::Inflight(serial);
                     return true;
                 }
                 ConfigureState::TimedOutAcked => {
                     self.configure_state = ConfigureState::Acked;
                     return true;
                 }
                 ConfigureState::Inflight(..) | ConfigureState::Acked | ConfigureState::Committed => {
                     return false;
                 }
             }
         }
 
         // Absorb a size-only ECHO: the scheduled size merely restates what the
         // client has already committed (its current geometry) and nothing else
         // changed. Sending it anyway hands a self-sizing client a stale size
         // one commit later — and when the client's content width flaps (the
         // cpu module's text crossing 10%), that stale echo re-triggers a
         // resize on both sides and the pair ping-pongs at frame rate (the
         // status-bar jitter: ~3300 alternating 95/104 configures in 5min).
         // Agree with reality instead and send nothing. A configure whose size
         // DIFFERS from the committed geometry — a real compositor-driven
         // resize — always goes through.
         {
             let echo_w = scheduled.width.or(sent.width);
             let echo_h = scheduled.height.or(sent.height);
             // Bounds are part of the echo, not a separate signal, when they
             // merely track the echoed size: the arrange schedules a status
             // window's bounds equal to its own box, so a self-resize ALWAYS
             // carries a matching bounds delta — requiring bounds equality
             // here would keep the absorb permanently disabled for exactly
             // the windows that loop. A bounds change that differs from the
             // echoed size (a real available-area change) still forces a
             // configure.
             let bounds_ok = (scheduled.bounds.width == sent.bounds.width
                 && scheduled.bounds.height == sent.bounds.height)
                 || (echo_w == Some(scheduled.bounds.width as u32)
                     && echo_h == Some(scheduled.bounds.height as u32));
             let non_size_equal = scheduled.activated == sent.activated
                 && scheduled.ssd == sent.ssd
                 && scheduled.tiled == sent.tiled
                 && scheduled.capabilities == sent.capabilities
                 && scheduled.maximized == sent.maximized
                 && scheduled.inform_fullscreen == sent.inform_fullscreen
                 && scheduled.resizing == sent.resizing;
             // Idle AND Committed: after any completed configure round-trip
             // the state machine RESTS in Committed (Acked → Committed on
             // commit; only the timeout path returns to Idle), so gating on
             // Idle alone leaves this absorb dead in steady state — the exact
             // moment the echo loop runs. Inflight/Acked stay excluded: a
             // real configure is mid-flight and the scheduled size may need
             // to supersede it.
             let size_is_echo = self.geometry.width > 0
                 && self.geometry.height > 0
                 && echo_w == Some(self.geometry.width as u32)
                 && echo_h == Some(self.geometry.height as u32);
             // Timeout recovery states absorb too: a hot echo loop drives the
             // machine into TimedOut/TimedOutAcked, and an absorb that disarms
             // there switches itself off at exactly the moment it exists for
             // (observed live: a title-flapping window module sustained a
             // 372↔456 storm at state=TimedOutAcked). Only Inflight/Acked stay
             // excluded — a real configure is mid-flight there. Absorbing
             // leaves the timeout recovery untouched: a late ack or the next
             // commit still walks the state back to Idle.
             if size_is_echo
                 && non_size_equal
                 && bounds_ok
                 && !matches!(
                     self.configure_state,
                     ConfigureState::Inflight(..) | ConfigureState::Acked
                 )
             {
                 let absorbed_bounds = scheduled.bounds;
                 (*self.window).configure_sent.width = echo_w;
                 (*self.window).configure_sent.height = echo_h;
                 (*self.window).configure_sent.bounds = absorbed_bounds;
                 (*self.window).configure_scheduled.width = None;
                 (*self.window).configure_scheduled.height = None;
                 return false;
             }
             if size_is_echo && log::log_enabled!(log::Level::Debug) {
                 // The size restates committed geometry yet the absorb
                 // declined — name the blocker (the state, or which non-size
                 // field), so a live echo loop is diagnosable from the log.
                 log::debug!(
                     "XdgToplevel::configure: echo NOT absorbed: state={:?} non_size_equal={} \
                      (bounds {}x{}/{}x{} act {}/{} ssd {}/{} tiled {:?}/{:?} caps {:?}/{:?} max {}/{} fs {}/{} rsz {}/{})",
                     self.configure_state, non_size_equal,
                     scheduled.bounds.width, scheduled.bounds.height, sent.bounds.width, sent.bounds.height,
                     scheduled.activated, sent.activated,
                     scheduled.ssd, sent.ssd,
                     scheduled.tiled, sent.tiled,
                     scheduled.capabilities, sent.capabilities,
                     scheduled.maximized, sent.maximized,
                     scheduled.inform_fullscreen, sent.inform_fullscreen,
                     scheduled.resizing, sent.resizing,
                 );
             }
         }
 
         ffi::wlr_xdg_toplevel_set_activated(self.wlr_toplevel, scheduled.activated);
         ffi::wlr_xdg_toplevel_set_tiled(
             self.wlr_toplevel,
             scheduled.tiled,
         );
         ffi::wlr_xdg_toplevel_set_wm_capabilities(
             self.wlr_toplevel,
             scheduled.capabilities,
         );
         ffi::wlr_xdg_toplevel_set_maximized(self.wlr_toplevel, scheduled.maximized);
         ffi::wlr_xdg_toplevel_set_fullscreen(self.wlr_toplevel, scheduled.inform_fullscreen);
         ffi::wlr_xdg_toplevel_set_resizing(self.wlr_toplevel, scheduled.resizing);
         
         if !self.decoration.is_null() {
             let mode = ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE;
             ffi::wlr_xdg_toplevel_decoration_v1_set_mode((*self.decoration).wlr_decoration, mode);
         }
 
         if scheduled.bounds.width != sent.bounds.width || scheduled.bounds.height != sent.bounds.height {
             ffi::wlr_xdg_toplevel_set_bounds(self.wlr_toplevel, scheduled.bounds.width as i32, scheduled.bounds.height as i32);
         }
 
         let width = if let Some(w) = scheduled.width {
             w
         } else if let Some(w) = (*self.window).configure_sent.width {
             w
         } else {
             self.geometry.width as u32
         };
 
         let height = if let Some(h) = scheduled.height {
             h
         } else if let Some(h) = (*self.window).configure_sent.height {
             h
         } else {
             self.geometry.height as u32
         };
 
         if log::log_enabled!(log::Level::Debug) {
             log::debug!(
                 "XdgToplevel::configure: sending size {}x{} (scheduled={:?}, sent={:?}, geometry={:?}) to client '{}'",
                 width, height, scheduled.width, sent.width, (self.geometry.width, self.geometry.height), (*self.window).get_title_string().unwrap_or_else(|| "None".to_string())
             );
         }
 
         let configure_serial = ffi::wlr_xdg_toplevel_set_size(self.wlr_toplevel, width as i32, height as i32);
 
         (*self.window).configure_sent = (*self.window).configure_scheduled.clone();
         (*self.window).configure_sent.width = Some(width);
         (*self.window).configure_sent.height = Some(height);
         (*self.window).configure_scheduled.width = None;
         (*self.window).configure_scheduled.height = None;
 
         if width != 0 && height != 0 &&
            width == self.geometry.width as u32 && height == self.geometry.height as u32 &&
            matches!(self.configure_state, ConfigureState::Idle) {
             return false;
         }
 
         self.configure_state = ConfigureState::Inflight(configure_serial);
         true
     }
 
     pub unsafe fn needs_configure(&self) -> bool {
         let scheduled = &(*self.window).configure_scheduled;
         let sent = &(*self.window).configure_sent;
 
         if scheduled.width.is_some() && scheduled.width != sent.width {
             return true;
         }
         if scheduled.height.is_some() && scheduled.height != sent.height {
             return true;
         }
         if scheduled.bounds.width != sent.bounds.width || scheduled.bounds.height != sent.bounds.height {
             return true;
         }
         if scheduled.activated != sent.activated {
             return true;
         }
         if scheduled.ssd != sent.ssd {
             return true;
         }
         if scheduled.tiled != sent.tiled {
             return true;
         }
         if scheduled.capabilities != sent.capabilities {
             return true;
         }
         if scheduled.maximized != sent.maximized {
             return true;
         }
         if scheduled.inform_fullscreen != sent.inform_fullscreen {
             return true;
         }
         if scheduled.resizing != sent.resizing {
             return true;
         }
 
         false
     }
 }
 
 unsafe extern "C" fn handle_destroy(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, destroy);
 
     if !(*toplevel).decoration.is_null() {
         XdgDecoration::deinit((*toplevel).decoration);
     }
 
     wl_listener_remove(&mut (*toplevel).destroy);
     wl_listener_remove(&mut (*toplevel).ack_configure);
     wl_listener_remove(&mut (*toplevel).map);
     wl_listener_remove(&mut (*toplevel).unmap);
     wl_listener_remove(&mut (*toplevel).commit);
     wl_listener_remove(&mut (*toplevel).new_popup);
     wl_listener_remove(&mut (*toplevel).request_show_window_menu);
     wl_listener_remove(&mut (*toplevel).request_fullscreen);
     wl_listener_remove(&mut (*toplevel).request_maximize);
     wl_listener_remove(&mut (*toplevel).request_minimize);
     wl_listener_remove(&mut (*toplevel).request_move);
     wl_listener_remove(&mut (*toplevel).request_resize);
     wl_listener_remove(&mut (*toplevel).set_parent);
     wl_listener_remove(&mut (*toplevel).set_title);
     wl_listener_remove(&mut (*toplevel).set_app_id);
 
     let base = ffi::river_wlr_xdg_toplevel_get_base((*toplevel).wlr_toplevel);
     ffi::river_wlr_xdg_surface_set_data(base, std::ptr::null_mut());
     let surface = ffi::river_wlr_xdg_surface_get_surface(base);
     ffi::river_wlr_surface_set_data(surface, std::ptr::null_mut());
 
     let window = (*toplevel).window;
     (*window).impl_destroying();
     match (*window).state {
         crate::window::WindowState::Init | crate::window::WindowState::Closing => {}
         crate::window::WindowState::Ready | crate::window::WindowState::Initialized | crate::window::WindowState::Mapped => {
             (*window).set_closing();
             (*(*window).server).wm.dirty_windowing();
         }
     }
 
     let _ = Box::from_raw(toplevel);
 }
 
 unsafe extern "C" fn handle_unmap(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, unmap);
     (*(*toplevel).window).unmap();
 }
 
 unsafe extern "C" fn handle_map(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, map);
     if let Err(e) = (*(*toplevel).window).map() {
         log::error!("Window map failed: {}", e);
         let client = ffi::wl_resource_get_client((*(*toplevel).wlr_toplevel).resource);
         ffi::wl_client_post_no_memory(client);
         return;
     }
 
     let base = ffi::river_wlr_xdg_toplevel_get_base((*toplevel).wlr_toplevel);
     let mut new_geometry = std::mem::zeroed();
     ffi::river_wlr_xdg_surface_get_geometry(base, &mut new_geometry);
     (*toplevel).geometry = new_geometry;
 
     // A fullscreen state the client set before its first commit never raises
     // request_fullscreen (wlroots only records it); honour it now that the
     // window is mapped. A fresh floating spawn has no box yet — the arrange
     // pass leaves it 0x0 so the acked-commit path adopts the natural size —
     // but that next commit will be the fullscreen one, so seed the box with
     // the size the window mapped at, or leaving fullscreen restores an
     // output-sized window.
     if ffi::river_wlr_xdg_toplevel_get_requested_fullscreen((*toplevel).wlr_toplevel) {
         let window = (*toplevel).window;
         if (*window).box_geom.width <= 0 && (*window).box_geom.height <= 0 && new_geometry.width > 0 && new_geometry.height > 0 {
             (*window).box_geom.width = new_geometry.width;
             (*window).box_geom.height = new_geometry.height;
         }
         (*(*window).server).wm.apply_client_fullscreen(window, true);
     }
     // Status segments and Utility windows are SELF-sizing: their bounds
     // track their own box, so the committed geometry is adopted as the box.
     let is_self_sized = matches!(
         (*(*toplevel).window).tiling_mode,
         crate::tiling::TilingMode::Status | crate::tiling::TilingMode::Utility
     ) || (*(*toplevel).window).get_app_id_string().map_or(false, |id| id.starts_with("cce-status"));
     if is_self_sized {
         (*(*toplevel).window).box_geom.width = new_geometry.width;
         (*(*toplevel).window).box_geom.height = new_geometry.height;
         // A view-centered modal that is ALSO self-sizing was centered at map
         // against a size it had not committed yet; redo it now that it has.
         (*(*toplevel).window).take_pending_view_center();
         (*(*(*toplevel).window).server).wm.dirty_windowing();
     } else if (*(*toplevel).window).pending_view_center
         && new_geometry.width > 0
         && new_geometry.height > 0
     {
         // A view-centered FLOATING window whose first size just arrived (the
         // file chooser): adopt the geometry and redo the centering, or the
         // map-time 400x400-floor placement stands for a 900x500 dialog.
         (*(*toplevel).window).box_geom.width = new_geometry.width;
         (*(*toplevel).window).box_geom.height = new_geometry.height;
         (*(*toplevel).window).take_pending_view_center();
         (*(*(*toplevel).window).server).wm.dirty_windowing();
     }
 }
 
 unsafe extern "C" fn handle_new_popup(listener: *mut ffi::wl_listener, data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, new_popup);
     let wlr_xdg_popup = data as *mut ffi::wlr_xdg_popup;
 
     let window = (*toplevel).window;
     let capture_node = &mut (*(*window).capture_scene).tree as *mut ffi::wlr_scene_tree;
     if let Err(e) = crate::xdg_popup::XdgPopup::create(
         wlr_xdg_popup,
         (*window).popup_tree,
         capture_node,
         (*window).popup_tree,
     ) {
         log::error!("Failed to create popup: {}", e);
         ffi::wl_resource_post_no_memory((*wlr_xdg_popup).resource);
         return;
     }
     // Opening a menu changes nothing the reorder pass's order hash can see,
     // so it schedules no transaction: without this raise a tiled window's
     // menu would stay under the floating plane until some unrelated restack
     // came along. The pass re-applies it from then on.
     (*(*window).server).wm.raise_focused_popups(window);
 }
 
 unsafe extern "C" fn handle_ack_configure(
     listener: *mut ffi::wl_listener,
     data: *mut std::ffi::c_void,
 ) {
     let toplevel = crate::container_of!(listener, XdgToplevel, ack_configure);
     let acked_configure = data as *mut ffi::wlr_xdg_surface_configure;
     let serial = (*acked_configure).serial;
 
     // Any ack, matching serial or not, proves the client is answering
     // configures: from here its geometry is a response, and `render_start`
     // may adopt it again.
     (*toplevel).acked_once = true;
 
     match (*toplevel).configure_state {
         ConfigureState::Inflight(s) => {
             if serial == s {
                 (*toplevel).configure_state = ConfigureState::Acked;
             }
         }
         ConfigureState::TimedOut(s) => {
             if serial == s {
                 (*toplevel).configure_state = ConfigureState::TimedOutAcked;
             }
         }
         _ => {}
     }
 
     let base = ffi::river_wlr_xdg_toplevel_get_base((*toplevel).wlr_toplevel);
     let mut new_geometry = std::mem::zeroed();
     ffi::river_wlr_xdg_surface_get_geometry(base, &mut new_geometry);
     (*toplevel).geometry = new_geometry;
 
     // Status segments and Utility windows are SELF-sizing: their bounds
     // track their own box, so the committed geometry is adopted as the box.
     let is_self_sized = matches!(
         (*(*toplevel).window).tiling_mode,
         crate::tiling::TilingMode::Status | crate::tiling::TilingMode::Utility
     ) || (*(*toplevel).window).get_app_id_string().map_or(false, |id| id.starts_with("cce-status"));
     if is_self_sized {
         (*(*toplevel).window).box_geom.width = new_geometry.width;
         (*(*toplevel).window).box_geom.height = new_geometry.height;
         // A view-centered modal that is ALSO self-sizing was centered at map
         // against a size it had not committed yet; redo it now that it has.
         (*(*toplevel).window).take_pending_view_center();
         (*(*(*toplevel).window).server).wm.dirty_windowing();
     } else if (*(*toplevel).window).pending_view_center
         && new_geometry.width > 0
         && new_geometry.height > 0
     {
         // A view-centered FLOATING window whose first size just arrived (the
         // file chooser): adopt the geometry and redo the centering, or the
         // map-time 400x400-floor placement stands for a 900x500 dialog.
         (*(*toplevel).window).box_geom.width = new_geometry.width;
         (*(*toplevel).window).box_geom.height = new_geometry.height;
         (*(*toplevel).window).take_pending_view_center();
         (*(*(*toplevel).window).server).wm.dirty_windowing();
     }
 }
 
 unsafe extern "C" fn handle_commit(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, commit);
     let window = (*toplevel).window;
     // Grid-patch latch: the first commit after ack_grid_patch carries the
     // buffer rendered for that patch — anchor to it from this commit on.
     // Latching here (not at ack time) means an in-flight older buffer is
     // never shown at the new anchor.
     if let Some((serial, patch)) = (*window).grid_patch_acked.take() {
         log::info!("[Grid] latched patch #{serial} on commit");
         (*window).grid_patch_current = Some(patch);
         // The commit swaps the BUFFER in the scene immediately, but the
         // anchor (position/scale/box) otherwise waits for the next arrange
         // pass — up to a frame of the new buffer drawn at the OLD patch's
         // anchor, the occasional one-frame cell flicker at a patch swap.
         // Apply the new anchor inline, mirroring the arrange Grid arm
         // exactly (virtual_to_screen's truncating cast included); the next
         // arrange re-affirms the same values.
         {
             let wm = &(*(*window).server).wm;
             let zoom = crate::policy::background::sanitized_zoom(wm.desk_zoom);
             let (mut ox, mut oy) = (0i32, 0i32);
             let outputs_list = &(*(*window).server).om.outputs as *const ffi::wl_list
                 as *mut WlList;
             let mut curr_out = (*outputs_list).next;
             while curr_out != outputs_list {
                 let output = crate::container_of!(curr_out, crate::output::Output, link);
                 if (*output).sent.state == crate::output::OutputStateValue::Enabled {
                     let b = (*output).sent.box_layout();
                     ox = b.x;
                     oy = b.y;
                     break;
                 }
                 curr_out = (*curr_out).next;
             }
             if patch.scale > 0.0 {
                 // Rounded like every other virtual->screen placement (the
                 // arrange pass and the fallback lattice); truncation here put
                 // the latched patch a pixel off the lattice it replaces.
                 let (lcam, _, _) = wm.layout_camera();
                 let sx = ox + ((patch.x - lcam.pan_x) * zoom).round() as i32;
                 let sy = oy + ((patch.y - lcam.pan_y) * zoom).round() as i32;
                 (*window).rendering_requested.x = sx;
                 (*window).rendering_requested.y = sy;
                 (*window).scale = zoom / patch.scale;
                 (*window).box_geom.x = sx;
                 (*window).box_geom.y = sy;
                 (*window).box_geom.width = (patch.w * patch.scale).round() as i32;
                 (*window).box_geom.height = (patch.h * patch.scale).round() as i32;
             }
         }
         // The grid sits in the optimized-blur capture set (backdrop layers):
         // new patch content invalidates the shared blurred-backdrop cache,
         // which nothing else re-bakes when the latch lands after the
         // viewport has settled — translucent windows keep showing a blur of
         // the pre-latch desktop.
         ffi::river_scene_mark_optimized_blur_dirty((*(*window).server).scene.wlr_scene);
         (*(*window).server).wm.dirty_windowing();
     }
     let base = ffi::river_wlr_xdg_toplevel_get_base((*toplevel).wlr_toplevel);
     let old_geometry = (*toplevel).geometry;
     let mut new_geometry = std::mem::zeroed();
     ffi::river_wlr_xdg_surface_get_geometry(base, &mut new_geometry);
     (*toplevel).geometry = new_geometry;
 
     // A commit that changes the window-geometry box or the surface extent
     // changes the surface↔frame mapping under a STATIONARY cursor (the scene
     // helper re-anchors the subtree by -geometry; a grown buffer adds
     // hoverable area): pointer focus and surface-local coords go stale with
     // no motion to fix them, and the next click is dispatched against the old
     // mapping or dropped — the cce-ui overflow-rim popovers exposed this.
     // Deferred to idle: wlroots' own scene commit listeners re-anchor AFTER
     // this handler, so an inline refresh would query the stale scene.
     {
         let surface = ffi::river_wlr_xdg_surface_get_surface(base);
         let surf_size = (
             ffi::river_wlr_surface_get_width(surface),
             ffi::river_wlr_surface_get_height(surface),
         );
         let mapping_changed = old_geometry.x != new_geometry.x
             || old_geometry.y != new_geometry.y
             || old_geometry.width != new_geometry.width
             || old_geometry.height != new_geometry.height
             || surf_size != (*toplevel).last_surface_size;
         (*toplevel).last_surface_size = surf_size;
         if mapping_changed
             && matches!((*window).state, crate::window::WindowState::Mapped)
         {
             (*(*window).server).input_manager.schedule_pointer_refresh();
         }
     }
 
     // Borrowed: this runs on every commit of every client.
     let app_id = (*window).app_id_str().unwrap_or_default();
     let mut ignore_transparent = (*(*window).server).wm.layout.window_backdrop_blur_ignore_transparent;
     if app_id.starts_with("cce-status") {
         ignore_transparent = (*(*window).server).wm.layout.status_backdrop_blur_ignore_transparent;
     }
     let scale = (*window).scale;
     let is_status = (*window).tiling_mode == crate::tiling::TilingMode::Status ||
                     app_id.starts_with("cce-status");
     let is_decorated = (*(*window).server).wm.is_decorated_app(&app_id);
     // Status segments are SELF-sizing (their bounds track their own box), so
     // the geometry of the commit being handled is the truth. `rendering_sent`
     // is a render-start snapshot that lags a contract commit by a render pass
     // — sizing the blur from it left a menu-sized blur ghost hanging below
     // the strip until the next commit re-ran this path.
     let (actual_w, actual_h) = if is_status && (*toplevel).geometry.width > 0 && (*toplevel).geometry.height > 0 {
         ((*toplevel).geometry.width as u32, (*toplevel).geometry.height as u32)
     } else {
         (
             if (*window).rendering_sent.width > 0 { (*window).rendering_sent.width } else { (*toplevel).geometry.width as u32 },
             if (*window).rendering_sent.height > 0 { (*window).rendering_sent.height } else { (*toplevel).geometry.height as u32 },
         )
     };
     let geom_w = (actual_w as f64 * scale) as i32;
     let geom_h = (actual_h as f64 * scale) as i32;
     // The same radius Window::set_rendering_state applies — the one
     // `root_plate_radius_base`, not a mirrored copy: both paths drive the same
     // blur node, and when two copies disagreed the corners flipped between
     // rounded and square depending on which one ran last.
     let radius = (*window).root_plate_radius_base();
     // Same span widening as Window::set_rendering_state (part of the mirror).
     let radius = if (*window).rendering_requested.circular {
         radius
     } else {
         crate::window::widen_corner_radius(radius, actual_w as i32, actual_h as i32)
     };
     // Rounded corners do NOT require live blur: the corner shape is applied by the
     // standard blur node's sampler (wlr_scene_blur_set_corner_radius) in both modes;
     // the optimized node only re-bakes the shared offscreen cache
     // (fx_render_pass_add_optimized_blur -> read_to_buffer) and never paints on
     // screen. The old `radius > 0` opt-out silently disabled the optimization for
     // every (rounded) window, forcing full-backdrop dual-kawase blur per frame per
     // translucent window — the DE-wide hover-lag / constant-GPU-load root cause.
     let use_optimized = if is_status {
         false
     } else {
         (*(*window).server).wm.layout.scenefx_optimized_blur
     };
     let blur_enabled = (*window).rendering_requested.blur && ((*window).wm_requested.ssd || is_decorated || is_status);
     ffi::river_scene_node_enable_blur(
         (*window).tree as *mut ffi::wlr_scene_node,
         blur_enabled,
         use_optimized,
         ignore_transparent,
         0,
         0,
         geom_w,
         geom_h,
         // geom_w/h are already scaled to device px; the radius must match.
         (radius as f64 * scale) as i32,
     );
     (*window).sync_backdrop_compress();
 
     let capture_node = &mut (*(*window).capture_scene).tree as *mut ffi::wlr_scene_tree as *mut ffi::wlr_scene_node;
     let mut geom = std::mem::zeroed();
     ffi::river_wlr_xdg_surface_get_geometry(base, &mut geom);
     ffi::wlr_scene_subsurface_tree_set_clip(capture_node, &geom);
 
     let mut min_w = 0;
     let mut min_h = 0;
     let mut max_w = 0;
     let mut max_h = 0;
     ffi::river_wlr_xdg_toplevel_get_requested_min_max_size((*toplevel).wlr_toplevel, &mut min_w, &mut min_h, &mut max_w, &mut max_h);
 
     (*window).set_dimensions_hint(crate::window::DimensionsHint {
         min_width: min_w as u32,
         min_height: min_h as u32,
         max_width: max_w as u32,
         max_height: max_h as u32,
     });
 
     if ffi::river_wlr_xdg_surface_get_initial_commit(base) {
         assert!((*window).state != crate::window::WindowState::Ready);
         if (*window).get_app_id_string().map_or(false, |id| id.starts_with("cce-status")) {
             log::debug!("[LinkDbg] initial commit -> ready app={:?} was_state={:?} linked={}",
                 (*window).get_app_id_string(), (*window).state, (*window).is_linked());
         }
         (*window).state = crate::window::WindowState::Ready;
         let mut new_geometry = std::mem::zeroed();
         ffi::river_wlr_xdg_surface_get_geometry(base, &mut new_geometry);
         (*toplevel).geometry = new_geometry;
 
         let is_self_sized = matches!(
             (*window).tiling_mode,
             crate::tiling::TilingMode::Status | crate::tiling::TilingMode::Utility
         ) || (*window).get_app_id_string().map_or(false, |id| id.starts_with("cce-status"));
         if is_self_sized {
             (*window).box_geom.width = new_geometry.width;
             (*window).box_geom.height = new_geometry.height;
         }
 
         (*(*window).server).wm.dirty_windowing();
         return;
     }
 
     if (*window).state != crate::window::WindowState::Mapped && (*window).state != crate::window::WindowState::Ready {
         return;
     }
 
     // A self-sizing overlay (cce-cloud) repaints at a new size on its own, with no
     // configure round trip. The size-change branches below can't catch it: they
     // compare against (*toplevel).geometry, which already holds the new value by
     // the time they run, so size_changed is never true. Track the live geometry
     // here instead and move the border with it, in the same commit that puts the
     // new buffer on screen — waiting for the WM cycle (which round-trips out to
     // the external window-manager client) leaves the border a size behind.
     // Utility windows self-size the same way (the arrange pass only ever
     // sends them the "you choose" 0x0, so every size change originates in a
     // client commit like this one). So do Popups: cce-cloud's launcher flags
     // itself one via set_popup and auto-sizes to its filtered list, and the
     // WM's Popup arm echoes box_geom back as the size — so without this the
     // border and blur stayed at the size the popup opened at while the list
     // shrank and grew under them as the user typed.
     if matches!(
         (*window).tiling_mode,
         crate::tiling::TilingMode::Overlay
             | crate::tiling::TilingMode::Utility
             | crate::tiling::TilingMode::Popup
     ) {
         let mut live = std::mem::zeroed();
         ffi::river_wlr_xdg_surface_get_geometry(base, &mut live);
         if live.width > 0 && live.height > 0
             && (live.width != (*window).box_geom.width || live.height != (*window).box_geom.height)
         {
             (*window).box_geom.width = live.width;
             (*window).box_geom.height = live.height;
             // render_finish would otherwise reset box_geom from the render-start
             // snapshot (rendering_sent) and snap the border back to the old size.
             (*window).self_resized = true;
             (*window).draw_borders();
             (*window).set_dimensions(live.width as u32, live.height as u32);
             (*(*window).server).wm.dirty_windowing();
         }
     }
 
     // Status segments self-size the same way when an in-surface menu grows or
     // contracts the surface (no configure round trip). Track the live
     // geometry in the same commit: box_geom feeds the expanded-state order
     // hash that restacks the segment into the popups layer, so a lagging
     // box_geom left the freshly opened menu stacked UNDER its sibling
     // segments (their text drew sharp over the menu's blur) for a beat.
     // Unlike the overlay branch, no set_dimensions — the WM deliberately
     // leaves status segment sizes to the client.
     if is_status {
         let mut live = std::mem::zeroed();
         ffi::river_wlr_xdg_surface_get_geometry(base, &mut live);
         if live.width > 0 && live.height > 0
             && (live.width != (*window).box_geom.width || live.height != (*window).box_geom.height)
         {
             (*window).box_geom.width = live.width;
             (*window).box_geom.height = live.height;
             (*window).self_resized = true;
             (*(*window).server).wm.dirty_windowing();
         }
     }
 
     match (*toplevel).configure_state {
         ConfigureState::Idle | ConfigureState::Committed | ConfigureState::TimedOut(..) => {
             // Nothing to do: client-initiated size/position changes CANNOT
             // be detected here. The top of handle_commit already refreshed
             // (*toplevel).geometry from this commit, so any comparison
             // against it never fires (the branch that used to live here was
             // dead for that reason). Self-sizing overlays are handled by the
             // live-geometry sync above; clients resizing through a configure
             // round trip land in the Acked arm.
         }
         ConfigureState::Inflight(..) => {
             (*window).send_frame_done();
         }
         ConfigureState::Acked | ConfigureState::TimedOutAcked => {
             let mut new_geometry = std::mem::zeroed();
             ffi::river_wlr_xdg_surface_get_geometry(base, &mut new_geometry);
             (*toplevel).geometry = new_geometry;
 
             (*window).rendering_scheduled.width = new_geometry.width as u32;
             (*window).rendering_scheduled.height = new_geometry.height as u32;
 
             let is_status = (*window).tiling_mode == crate::tiling::TilingMode::Status ||
                             (*window).get_app_id_string().map_or(false, |id| id.starts_with("cce-status"));
             // Overlay included so its scheduled size tracks the client's own; the
             // border itself is handled by the live-geometry sync above.
             let is_overlay = (*window).tiling_mode == crate::tiling::TilingMode::Overlay;
             let is_utility = (*window).tiling_mode == crate::tiling::TilingMode::Utility;
             if matches!((*window).tiling_mode, crate::tiling::TilingMode::Floating | crate::tiling::TilingMode::Popup) || is_status || is_overlay || is_utility {
                 (*window).set_dimensions(new_geometry.width as u32, new_geometry.height as u32);
                 if is_status {
                     // Only a size that actually moved re-arranges. A status
                     // segment acks a configure and commits at its old size
                     // for every content refresh; each of those used to run
                     // a full manage/arrange/render transaction.
                     let (w, h) = (new_geometry.width, new_geometry.height);
                     if w != (*window).box_geom.width || h != (*window).box_geom.height {
                         (*window).box_geom.width = w;
                         (*window).box_geom.height = h;
                         (*(*window).server).wm.dirty_windowing();
                     }
                 }
             }
 
             let (dec_w, dec_h) = (*window).get_decorations_size();
             if dec_w != (*window).last_decor_w || dec_h != (*window).last_decor_h {
                 (*window).last_decor_w = dec_w;
                 (*window).last_decor_h = dec_h;
                 (*(*window).server).wm.dirty_windowing();
             }
 
             if let Some(sent_w) = (*window).configure_sent.width {
                 if !(*window).wm_requested.ssd && dec_w > 0 && new_geometry.width as u32 == sent_w.saturating_sub(dec_w as u32) {
                     if !(*window).csd_buffer_size_bug {
                         (*window).csd_buffer_size_bug = true;
                         log::info!("Detected CSD buffer size bug for window '{}'. Activating workaround.", (*window).get_title_string().unwrap_or_default());
                         (*(*window).server).wm.dirty_windowing();
                     }
                 }
             }
 
             match (*toplevel).configure_state {
                 ConfigureState::Acked => {
                     (*toplevel).configure_state = ConfigureState::Committed;
                     (*(*window).server).wm.notify_configured();
                 }
                 ConfigureState::TimedOutAcked => {
                     (*toplevel).configure_state = ConfigureState::Idle;
                     (*(*window).server).wm.dirty_rendering();
                 }
                 _ => unreachable!(),
             }
         }
     }
 
     // Left/top-edge anchoring on the committed geometry — the shared
     // Window::anchor_resize_commit; Xwayland windows take the same path from
     // handle_window_commit.
     let geometry = (*toplevel).geometry;
     if let Some((final_x, final_y)) = (*window).anchor_resize_commit(geometry.width, geometry.height) {
         let server = (*window).server;
         // Keep the displayed buffer and the compensating position atomic.
         // Live buffer (no configure in flight): the commit is already on
         // screen, so move the scene tree in the same commit — waiting for
         // the next render pass lets a frame composite the new size at the
         // old position, jittering the anchored edges. Frozen buffer (saved
         // for an in-flight configure): moving the tree now would shift the
         // OLD-size buffer instead, so leave the position to the render pass
         // (which restores the new buffer and applies it together) and make
         // sure that pass runs promptly.
         if !(*window).surfaces.saved {
             ffi::river_scene_node_set_position_if_changed((*window).tree as *mut ffi::wlr_scene_node, final_x, final_y);
             ffi::river_scene_node_set_position_if_changed((*window).popup_tree as *mut ffi::wlr_scene_node, final_x, final_y);
             (*window).box_geom.width = geometry.width;
             (*window).box_geom.height = geometry.height;
             (*window).draw_borders();
         } else {
             (*server).wm.dirty_rendering();
         }
     }
 }
 
 unsafe extern "C" fn handle_request_show_window_menu(
     listener: *mut ffi::wl_listener,
     data: *mut std::ffi::c_void,
 ) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_show_window_menu);
     let event = data as *mut ffi::wlr_xdg_toplevel_show_window_menu_event;
     let window = (*toplevel).window;
 
     (*window).wm_scheduled.show_window_menu_requested = Some(crate::window::ShowWindowMenuRequest {
         x: (*event).x - (*toplevel).geometry.x,
         y: (*event).y - (*toplevel).geometry.y,
     });
     (*(*window).server).wm.dirty_windowing();
 }
 
 unsafe extern "C" fn handle_request_fullscreen(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_fullscreen);
     let window = (*toplevel).window;
 
     if ffi::river_wlr_xdg_toplevel_get_requested_fullscreen((*toplevel).wlr_toplevel) {
         let wlr_output = ffi::river_wlr_xdg_toplevel_get_requested_fullscreen_output((*toplevel).wlr_toplevel);
         if !wlr_output.is_null() {
             let output = ffi::river_wlr_output_get_data(wlr_output) as *mut crate::output::Output;
             (*window).wm_scheduled.fullscreen_requested = crate::window::FullscreenRequest::Fullscreen(output);
         } else {
             (*window).wm_scheduled.fullscreen_requested = crate::window::FullscreenRequest::Fullscreen(std::ptr::null_mut());
         }
     } else {
         (*window).wm_scheduled.fullscreen_requested = crate::window::FullscreenRequest::Exit;
     }
     (*(*window).server).wm.dirty_windowing();
     let enter = ffi::river_wlr_xdg_toplevel_get_requested_fullscreen((*toplevel).wlr_toplevel);
     (*(*window).server).wm.apply_client_fullscreen(window, enter);
 }
 
 unsafe extern "C" fn handle_request_maximize(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_maximize);
     let window = (*toplevel).window;
 
     // A Utility window declared itself content-shaped; a maximize would hand
     // sizing back to the compositor. Explicitly ignored, not just unmapped
     // from any affordance.
     if (*window).tiling_mode == crate::tiling::TilingMode::Utility {
         return;
     }
 
     if ffi::river_wlr_xdg_toplevel_get_requested_maximized((*toplevel).wlr_toplevel) {
         (*window).tiling_mode = crate::tiling::TilingMode::Tiled;
         (*window).mode_locked = true;
         (*window).wm_scheduled.maximize_requested = crate::window::MaximizeRequest::Maximize;
     } else {
         (*window).tiling_mode = crate::tiling::TilingMode::Floating;
         (*window).mode_locked = true;
         (*window).wm_scheduled.maximize_requested = crate::window::MaximizeRequest::Unmaximize;
     }
     (*(*window).server).wm.dirty_windowing();
 }
 
 unsafe extern "C" fn handle_request_minimize(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_minimize);
     let window = (*toplevel).window;
 
     (*window).wm_scheduled.minimize_requested = true;
     (*(*window).server).wm.dirty_windowing();
 }
 
 unsafe extern "C" fn handle_request_move(
     listener: *mut ffi::wl_listener,
     data: *mut std::ffi::c_void,
 ) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_move);
     let event = data as *mut ffi::wlr_xdg_toplevel_move_event;
     let window = (*toplevel).window;
     let seat = ffi::river_wlr_seat_get_data((*(*event).seat).seat) as *mut crate::seat::Seat;
 
     if ffi::wlr_seat_validate_pointer_grab_serial((*seat).wlr_seat, std::ptr::null_mut(), (*event).serial) {
         let initial_mode = (*window).tiling_mode;
         // A client's move (a cce-ui window-plate drag) is the bound edit-mode
         // drag in every way that matters: read the Tiled grab BEFORE the
         // un-tile below, so the drag snaps to whole cells and lands grid-
         // aligned, which re-tiles it (op_end's `settle_tiling`). Read after,
         // as it was until 2026-10-06, it was always false: the drag moved
         // freely and the window stayed floating wherever it was dropped.
         let grabbed_tiled = initial_mode == crate::tiling::TilingMode::Tiled;
         if initial_mode != crate::tiling::TilingMode::Floating
             && initial_mode != crate::tiling::TilingMode::Popup
             && initial_mode != crate::tiling::TilingMode::Fullscreen
             && initial_mode != crate::tiling::TilingMode::Overlay
             // A move must not cost a window its Utility mode.
             && initial_mode != crate::tiling::TilingMode::Utility
         {
             // As the bound drag: un-tile for the drag but keep the
             // cell-quantized geometry (cursor.rs).
             (*window).was_tiled = false;
             (*window).tiling_mode = crate::tiling::TilingMode::Floating;
             (*window).mode_locked = true;
         }
 
         (*seat).focus(crate::seat::Focus::Window(window));
         (*(*window).server).wm.stop_panning_animation();
         let cursor = &mut (*seat).cursor;
         let cursor_x = (*cursor.wlr_cursor).x;
         let cursor_y = (*cursor.wlr_cursor).y;
 
         (*seat).op = Some(crate::seat::SeatOp {
             sent_release: false,
             input: crate::seat::SeatOpInput::Pointer,
             start_x: cursor_x as i32,
             start_y: cursor_y as i32,
             x: cursor_x as i32,
             y: cursor_y as i32,
             window_ptr: window,
             op_type: crate::seat::PointerOpType::Move,
             start_win_x: (*window).box_geom.x,
             start_win_y: (*window).box_geom.y,
             start_win_w: (*window).box_geom.width as u32,
             start_win_h: (*window).box_geom.height as u32,
             start_win_virtual_x: (*window).virtual_x,
             start_win_virtual_y: (*window).virtual_y,
             start_tiling_mode: (*window).tiling_mode,
             start_was_tiled: grabbed_tiled,
             start_mode_locked: (*window).mode_locked,
             start_pan_x: (*(*window).server).wm.desk_pan_x,
             start_pan_y: (*(*window).server).wm.desk_pan_y,
             started_in_overview: (*(*window).server).wm.mode == crate::window_manager::WindowManagerMode::Overview,
         });
         cursor.op_start_pointer();
         cursor.set_xcursor(b"grab\0".as_ptr() as *const _);
 
         (*window).wm_scheduled.pointer_move_requested = seat;
         (*(*window).server).wm.dirty_windowing();
     }
 }
 
 unsafe extern "C" fn handle_request_resize(
     listener: *mut ffi::wl_listener,
     data: *mut std::ffi::c_void,
 ) {
     let toplevel = crate::container_of!(listener, XdgToplevel, request_resize);
     let event = data as *mut ffi::wlr_xdg_toplevel_resize_event;
     let window = (*toplevel).window;
 
     // Nothing may interactively resize a Utility window — its size is the
     // client's `settings()` data, not a drag. Rejected at the request, not
     // just left without an affordance.
     if (*window).tiling_mode == crate::tiling::TilingMode::Utility {
         return;
     }
 
     let seat = ffi::river_wlr_seat_get_data((*(*event).seat).seat) as *mut crate::seat::Seat;
 
     if ffi::wlr_seat_validate_pointer_grab_serial((*seat).wlr_seat, std::ptr::null_mut(), (*event).serial) {
         let initial_mode = (*window).tiling_mode;
         // As in `handle_request_move`: read the Tiled grab before the
         // un-tile, so a client's edge resize snaps to whole cells like the
         // bound one and re-tiles where it lands, instead of leaving the
         // window floating.
         let grabbed_tiled = initial_mode == crate::tiling::TilingMode::Tiled;
         if initial_mode != crate::tiling::TilingMode::Floating
             && initial_mode != crate::tiling::TilingMode::Popup
             && initial_mode != crate::tiling::TilingMode::Fullscreen
         {
             (*window).was_tiled = false;
             (*window).tiling_mode = crate::tiling::TilingMode::Floating;
             (*window).mode_locked = true;
         }
 
         (*seat).focus(crate::seat::Focus::Window(window));
         (*(*window).server).wm.stop_panning_animation();
         let cursor = &mut (*seat).cursor;
         let cursor_x = (*cursor.wlr_cursor).x;
         let cursor_y = (*cursor.wlr_cursor).y;
 
         let edges = crate::window::Edges::from_u32((*event).edges);
         (*seat).op = Some(crate::seat::SeatOp {
             sent_release: false,
             input: crate::seat::SeatOpInput::Pointer,
             start_x: cursor_x as i32,
             start_y: cursor_y as i32,
             x: cursor_x as i32,
             y: cursor_y as i32,
             window_ptr: window,
             op_type: crate::seat::PointerOpType::Resize {
                 edges,
             },
             start_win_x: (*window).box_geom.x,
             start_win_y: (*window).box_geom.y,
             start_win_w: (*window).box_geom.width as u32,
             start_win_h: (*window).box_geom.height as u32,
             start_win_virtual_x: (*window).virtual_x,
             start_win_virtual_y: (*window).virtual_y,
             start_tiling_mode: (*window).tiling_mode,
             start_was_tiled: grabbed_tiled,
             start_mode_locked: (*window).mode_locked,
             start_pan_x: (*(*window).server).wm.desk_pan_x,
             start_pan_y: (*(*window).server).wm.desk_pan_y,
             started_in_overview: (*(*window).server).wm.mode == crate::window_manager::WindowManagerMode::Overview,
         });
         cursor.op_start_pointer();
         let cursor_name = crate::cursor::get_resize_cursor_name(edges);
         cursor.set_xcursor(cursor_name.as_ptr() as *const _);
 
         (*window).wm_scheduled.pointer_resize_requested = Some(crate::window::PointerResizeRequest {
             seat,
             edges: (*event).edges,
         });
         (*(*window).server).wm.dirty_windowing();
     }
 }
 
 unsafe extern "C" fn handle_set_parent(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, set_parent);
     let window = (*toplevel).window;
     (*(*window).server).wm.dirty_windowing();
 }
 
 unsafe extern "C" fn handle_set_title(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, set_title);
     let window = (*toplevel).window;
     (*window).notify_title();
 }
 
 unsafe extern "C" fn handle_set_app_id(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let toplevel = crate::container_of!(listener, XdgToplevel, set_app_id);
     let window = (*toplevel).window;
     (*window).notify_app_id();
 }
 
 unsafe extern "C" fn handle_decoration_destroy(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let decoration = crate::container_of!(listener, XdgDecoration, destroy);
     XdgDecoration::deinit(decoration);
 }
 
 unsafe extern "C" fn handle_decoration_request_mode(listener: *mut ffi::wl_listener, _data: *mut std::ffi::c_void) {
     let decoration = crate::container_of!(listener, XdgDecoration, request_mode);
     
     let base = ffi::river_wlr_xdg_toplevel_get_base((*(*decoration).wlr_decoration).toplevel);
     let toplevel = ffi::river_wlr_xdg_surface_get_data(base) as *mut XdgToplevel;
     let window = (*toplevel).window;
 
     let hint = match (*(*decoration).wlr_decoration).requested_mode {
         ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_NONE => {
             ffi::zcce_window_v1_decoration_hint_ZCCE_WINDOW_V1_DECORATION_HINT_NO_PREFERENCE
         }
         ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE => {
             ffi::zcce_window_v1_decoration_hint_ZCCE_WINDOW_V1_DECORATION_HINT_PREFERS_CSD
         }
         ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE => {
             ffi::zcce_window_v1_decoration_hint_ZCCE_WINDOW_V1_DECORATION_HINT_PREFERS_SSD
         }
         _ => ffi::zcce_window_v1_decoration_hint_ZCCE_WINDOW_V1_DECORATION_HINT_NO_PREFERENCE,
     };
     (*window).set_decoration_hint(hint);
 
     if ffi::river_wlr_xdg_surface_get_initialized(base) {
         let mut mode = (*(*decoration).wlr_decoration).requested_mode;
         if mode == ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_NONE {
             let server = (*window).server;
             let rule_ssd = (*server).wm.get_rule_for_window(window).and_then(|r| r.ssd);
             if let Some(true) = rule_ssd {
                 mode = ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE;
             } else {
                 mode = ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
             }
         }
         ffi::wlr_xdg_toplevel_decoration_v1_set_mode((*decoration).wlr_decoration, mode);
         (*window).wm_requested.ssd = mode == ffi::wlr_xdg_toplevel_decoration_v1_mode_WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE;
         (*(*window).server).wm.dirty_windowing();
     }
 }
 
 impl XdgDecoration {
     pub unsafe fn init(wlr_decoration: *mut ffi::wlr_xdg_toplevel_decoration_v1) -> *mut Self {
         let base = ffi::river_wlr_xdg_toplevel_get_base((*wlr_decoration).toplevel);
         let toplevel = ffi::river_wlr_xdg_surface_get_data(base) as *mut XdgToplevel;
 
         let decoration = Box::into_raw(Box::new(XdgDecoration {
             wlr_decoration,
             destroy: std::mem::zeroed(),
             request_mode: std::mem::zeroed(),
         }));
 
         (*toplevel).decoration = decoration;
 
         let destroy_ptr = &mut (*decoration).destroy as *mut ffi::wl_listener as *mut WlListener;
         (*destroy_ptr).notify = Some(handle_decoration_destroy);
         wl_signal_add(&mut (*wlr_decoration).events.destroy, &mut (*decoration).destroy);
 
         let req_mode_ptr = &mut (*decoration).request_mode as *mut ffi::wl_listener as *mut WlListener;
         (*req_mode_ptr).notify = Some(handle_decoration_request_mode);
         wl_signal_add(&mut (*wlr_decoration).events.request_mode, &mut (*decoration).request_mode);
 
         if ffi::river_wlr_xdg_surface_get_initialized(base) {
             handle_decoration_request_mode(&mut (*decoration).request_mode, std::ptr::null_mut());
         }
 
         decoration
     }
 
     pub unsafe fn deinit(decoration: *mut XdgDecoration) {
         let base = ffi::river_wlr_xdg_toplevel_get_base((*(*decoration).wlr_decoration).toplevel);
         let toplevel = ffi::river_wlr_xdg_surface_get_data(base) as *mut XdgToplevel;
 
         wl_listener_remove(&mut (*decoration).destroy);
         wl_listener_remove(&mut (*decoration).request_mode);
 
         assert!(!(*toplevel).decoration.is_null());
         (*toplevel).decoration = std::ptr::null_mut();
 
         let _ = Box::from_raw(decoration);
     }
 }