refactor(wayland): update data in user data map for everything

src/nodes/items/panel.rs

@@ -22,6 +22,15 @@ use std::sync::{Arc, Weak};
 use tracing::{debug, info};
 
 stardust_xr_server_codegen::codegen_item_panel_protocol!();
+impl Default for Geometry {
+	fn default() -> Self {
+		Geometry {
+			origin: [0, 0].into(),
+			size: [0, 0].into(),
+		}
+	}
+}
+
 lazy_static! {
 	pub static ref ITEM_TYPE_INFO_PANEL: TypeInfo = TypeInfo {
 		type_name: "panel",

src/wayland/compositor.rs

@@ -1,7 +1,7 @@
 use super::{
 	state::{ClientState, WaylandState},
-	utils::WlSurfaceExt,
-	xdg_shell::{surface_panel_item, ChildInfoExt},
+	utils::{ChildInfoExt, WlSurfaceExt},
+	xdg_shell::surface_panel_item,
 };
 use crate::{
 	nodes::items::panel::{ChildInfo, Geometry, SurfaceId},

src/wayland/seat.rs

@@ -1,4 +1,4 @@
-use super::{state::WaylandState, surface::CoreSurface};
+use super::{state::WaylandState, surface::CoreSurface, utils::WlSurfaceExt};
 use crate::{
 	core::task,
 	nodes::{
@@ -76,8 +76,7 @@ pub struct CursorInfo {
 }
 impl CursorInfo {
 	pub fn cursor_data(&self) -> Option<Geometry> {
-		let cursor_size =
-			CoreSurface::from_wl_surface(&self.surface.as_ref()?.upgrade().ok()?)?.size()?;
+		let cursor_size = self.surface.as_ref()?.upgrade().ok()?.get_size()?;
 		Some(Geometry {
 			origin: [self.hotspot_x, self.hotspot_y].into(),
 			size: cursor_size,

src/wayland/surface.rs

@@ -9,7 +9,6 @@ use crate::{
 		items::camera::TexWrapper,
 	},
 };
-use mint::Vector2;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use send_wrapper::SendWrapper;
@@ -35,7 +34,6 @@ pub static CORE_SURFACES: Registry<CoreSurface> = Registry::new();
 
 pub struct CoreSurfaceData {
 	wl_tex: Option<SendWrapper<GlesTexture>>,
-	pub size: Vector2<u32>,
 }
 impl Drop for CoreSurfaceData {
 	fn drop(&mut self) {
@@ -156,16 +154,7 @@ impl CoreSurface {
 			sk_mat.lock().0.queue_offset(*material_offset as i32);
 		}
 
-		let Some(surface_size) = wl_surface
-			.get_data_raw::<RendererSurfaceStateUserData, _, _>(|surface_states| {
-				surface_states.lock().unwrap().surface_size()
-			})
-			.flatten()
-		else {
-			return;
-		};
 		let new_mapped_data = CoreSurfaceData {
-			size: Vector2::from([surface_size.w as u32, surface_size.h as u32]),
 			wl_tex: Some(SendWrapper::new(smithay_tex)),
 		};
 		*mapped_data = Some(new_mapped_data);
@@ -206,10 +195,6 @@ impl CoreSurface {
 	pub fn wl_surface(&self) -> Option<WlSurface> {
 		self.weak_surface.upgrade().ok()
 	}
-
-	pub fn size(&self) -> Option<Vector2<u32>> {
-		self.mapped_data.lock().as_ref().map(|d| d.size)
-	}
 }
 impl Drop for CoreSurface {
 	fn drop(&mut self) {

src/wayland/utils.rs

@@ -1,9 +1,25 @@
-use smithay::{reexports::wayland_server::protocol::wl_surface::WlSurface, wayland::compositor};
+use mint::Vector2;
+use parking_lot::Mutex;
+use smithay::{
+	backend::renderer::utils::RendererSurfaceStateUserData,
+	reexports::wayland_server::protocol::wl_surface::WlSurface,
+	wayland::{
+		compositor,
+		shell::xdg::{SurfaceCachedState, XdgToplevelSurfaceData},
+	},
+};
 
+use crate::nodes::items::panel::{ChildInfo, Geometry, ToplevelInfo};
+
+use super::xdg_shell::surface_panel_item;
 pub trait WlSurfaceExt {
 	fn insert_data<T: Send + Sync + 'static>(&self, data: T) -> bool;
 	fn get_data<T: Send + Sync + Clone + 'static>(&self) -> Option<T>;
 	fn get_data_raw<T: Send + Sync + 'static, O, F: FnOnce(&T) -> O>(&self, f: F) -> Option<O>;
+	fn get_current_surface_state(&self) -> SurfaceCachedState;
+	fn get_pending_surface_state(&self) -> SurfaceCachedState;
+	fn get_size(&self) -> Option<Vector2<u32>>;
+	fn get_geometry(&self) -> Option<Geometry>;
 }
 impl WlSurfaceExt for WlSurface {
 	fn insert_data<T: Send + Sync + 'static>(&self, data: T) -> bool {
@@ -17,4 +33,97 @@ impl WlSurfaceExt for WlSurface {
 	fn get_data_raw<T: Send + Sync + 'static, O, F: FnOnce(&T) -> O>(&self, f: F) -> Option<O> {
 		compositor::with_states(self, |d| Some((f)(d.data_map.get::<T>()?)))
 	}
+	fn get_current_surface_state(&self) -> SurfaceCachedState {
+		compositor::with_states(self, |states| {
+			states
+				.cached_state
+				.get::<SurfaceCachedState>()
+				.current()
+				.clone()
+		})
+	}
+	fn get_pending_surface_state(&self) -> SurfaceCachedState {
+		compositor::with_states(self, |states| {
+			states
+				.cached_state
+				.get::<SurfaceCachedState>()
+				.pending()
+				.clone()
+		})
+	}
+	fn get_size(&self) -> Option<Vector2<u32>> {
+		self.get_data_raw::<RendererSurfaceStateUserData, _, _>(|surface_states| {
+			surface_states.lock().unwrap().surface_size()
+		})
+		.flatten()
+		.map(|size| Vector2::from([size.w as u32, size.h as u32]))
+	}
+	fn get_geometry(&self) -> Option<Geometry> {
+		self.get_current_surface_state().geometry.map(|r| r.into())
+	}
+}
+
+pub trait ToplevelInfoExt {
+	fn get_toplevel_info(&self) -> Option<ToplevelInfo>;
+	fn with_toplevel_info<O, F: FnOnce(&mut ToplevelInfo) -> O>(&self, f: F) -> Option<O>;
+
+	fn get_parent(&self) -> Option<u64>;
+	fn get_app_id(&self) -> Option<String>;
+	fn get_title(&self) -> Option<String>;
+	fn min_size(&self) -> Option<Vector2<u32>>;
+	fn max_size(&self) -> Option<Vector2<u32>>;
+}
+impl ToplevelInfoExt for WlSurface {
+	fn get_toplevel_info(&self) -> Option<ToplevelInfo> {
+		self.get_data_raw::<Mutex<ToplevelInfo>, _, _>(|c| c.lock().clone())
+	}
+	fn with_toplevel_info<O, F: FnOnce(&mut ToplevelInfo) -> O>(&self, f: F) -> Option<O> {
+		self.get_data_raw::<Mutex<ToplevelInfo>, _, _>(|r| (f)(&mut r.lock()))
+	}
+
+	fn get_parent(&self) -> Option<u64> {
+		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().unwrap().parent.clone())
+			.flatten()
+			.and_then(|p| surface_panel_item(&p))
+			.and_then(|p| p.node.upgrade())
+			.map(|p| p.get_id())
+	}
+	fn get_app_id(&self) -> Option<String> {
+		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().ok()?.app_id.clone())
+			.flatten()
+	}
+	fn get_title(&self) -> Option<String> {
+		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().ok()?.title.clone())
+			.flatten()
+	}
+	fn min_size(&self) -> Option<Vector2<u32>> {
+		let state = self.get_pending_surface_state();
+		let size = state.min_size;
+		if size.w == 0 && size.h == 0 {
+			None
+		} else {
+			Some(Vector2::from([size.w as u32, size.h as u32]))
+		}
+	}
+	fn max_size(&self) -> Option<Vector2<u32>> {
+		let state = self.get_pending_surface_state();
+		let size = state.max_size;
+		if size.w == 0 && size.h == 0 {
+			None
+		} else {
+			Some(Vector2::from([size.w as u32, size.h as u32]))
+		}
+	}
+}
+pub trait ChildInfoExt {
+	fn get_child_info(&self) -> Option<ChildInfo>;
+	fn with_child_info<O, F: FnOnce(&mut ChildInfo) -> O>(&self, f: F) -> Option<O>;
+}
+impl ChildInfoExt for WlSurface {
+	fn get_child_info(&self) -> Option<ChildInfo> {
+		self.get_data_raw::<Mutex<ChildInfo>, _, _>(|c| c.lock().clone())
+	}
+	fn with_child_info<O, F: FnOnce(&mut ChildInfo) -> O>(&self, f: F) -> Option<O> {
+		self.get_data_raw::<Mutex<ChildInfo>, _, _>(|r| (f)(&mut r.lock()))
+	}
 }