StardustXR/server
1
0
Fork 0
Code Issues 11 Pull Requests 3 Actions Packages Projects Releases 5 Wiki Activity

fix(wayland): remove unwraps

Browse Source
This commit is contained in:
Nova
2022-11-11 12:52:51 -05:00
parent 75ac570486
commit 46d989ce7f
6 changed files with 217 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/wayland/compositor.rs
View File

@@ -1,6 +1,5 @@
use super::{state::WaylandState, surface::CoreSurface}; use super::{state::WaylandState, surface::CoreSurface};
use smithay::{ use smithay::{
backend::renderer::utils::on_commit_buffer_handler,
delegate_compositor, delegate_compositor,
reexports::wayland_server::protocol::wl_surface::WlSurface, reexports::wayland_server::protocol::wl_surface::WlSurface,
wayland::compositor::{self, CompositorHandler, CompositorState}, wayland::compositor::{self, CompositorHandler, CompositorState},
@@ -12,7 +11,6 @@ impl CompositorHandler for WaylandState {
} }
fn commit(&mut self, surface: &WlSurface) { fn commit(&mut self, surface: &WlSurface) {
on_commit_buffer_handler(surface);
compositor::with_states(surface, |data| { compositor::with_states(surface, |data| {
data.data_map.insert_if_missing_threadsafe(|| { data.data_map.insert_if_missing_threadsafe(|| {
CoreSurface::new( CoreSurface::new(

14
src/wayland/mod.rs
View File

@@ -149,15 +149,13 @@ impl Wayland {
let time_ms = (sk.time_getf() * 1000.) as u64; let time_ms = (sk.time_getf() * 1000.) as u64;
for core_surface in CORE_SURFACES.get_valid_contents() { for core_surface in CORE_SURFACES.get_valid_contents() {
let client_id = match core_surface.wl_surface().client() { let Some(client_id) =
Some(client) => client.id(), core_surface
None => continue, .wl_surface()
}; .and_then(|surf| surf.client())
.map(|c| c.id()) else { continue };
let state = self.state.lock(); let state = self.state.lock();
let seat_data = match state.seats.get(&client_id) { let Some(seat_data) = state.seats.get(&client_id).cloned() else { continue };
Some(seat_data) => seat_data.clone(),
None => continue,
};
let output = state.output.clone(); let output = state.output.clone();
core_surface.process( core_surface.process(
sk, sk,

339
src/wayland/panel_item.rs
View File

@@ -22,7 +22,10 @@ use serde::Deserialize;
use smithay::{ use smithay::{
reexports::wayland_server::protocol::wl_pointer::{Axis, ButtonState}, reexports::wayland_server::protocol::wl_pointer::{Axis, ButtonState},
utils::Size, utils::Size,
wayland::{compositor::SurfaceData, shell::xdg::XdgToplevelSurfaceData}, wayland::{
compositor::SurfaceData,
shell::xdg::{Configure, XdgToplevelSurfaceData},
},
}; };
use stardust_xr::schemas::flex::{deserialize, serialize}; use stardust_xr::schemas::flex::{deserialize, serialize};
use std::sync::{Arc, Weak}; use std::sync::{Arc, Weak};
@@ -103,11 +106,11 @@ impl PanelItem {
node node
} }
pub fn from_node(node: &Node) -> &PanelItem { pub fn from_node(node: &Node) -> Option<&PanelItem> {
match &node.item.get().unwrap().specialization { node.item.get().and_then(|item| match &item.specialization {
ItemType::Panel(panel_item) => panel_item, ItemType::Panel(panel_item) => Some(panel_item),
_ => unreachable!(), _ => None,
} })
} }
fn apply_surface_material_flex( fn apply_surface_material_flex(
@@ -144,6 +147,20 @@ impl PanelItem {
calling_client: Arc<Client>, calling_client: Arc<Client>,
data: &[u8], data: &[u8],
) -> Result<()> { ) -> Result<()> {
let panel_item = match PanelItem::from_node(node) {
Some(panel_item) => panel_item,
None => return Ok(()),
};
let cursor = panel_item.seat_data.cursor.lock();
let cursor = match &*cursor {
Some(core_surface) => core_surface,
None => return Ok(()),
};
let core_surface = match cursor.lock().core_surface.upgrade() {
Some(core_surface) => core_surface,
None => return Ok(()),
};
#[derive(Deserialize)] #[derive(Deserialize)]
struct SurfaceMaterialInfo<'a> { struct SurfaceMaterialInfo<'a> {
model_path: &'a str, model_path: &'a str,
@@ -159,13 +176,7 @@ impl PanelItem {
.get() .get()
.ok_or_else(|| anyhow!("Node is not a model"))?; .ok_or_else(|| anyhow!("Node is not a model"))?;
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { core_surface.apply_material(model.clone(), info.idx);
if let Some(cursor) = &*panel_item.seat_data.cursor.lock() {
if let Some(core_surface) = cursor.lock().core_surface.upgrade() {
core_surface.apply_material(model.clone(), info.idx);
}
}
}
Ok(()) Ok(())
} }
@@ -187,25 +198,22 @@ impl PanelItem {
} }
pub fn if_mapped(_core_surface: &Arc<CoreSurface>, surface_data: &SurfaceData) { pub fn if_mapped(_core_surface: &Arc<CoreSurface>, surface_data: &SurfaceData) {
if let Some(panel_node) = surface_data.data_map.get::<Arc<Node>>() { let Some(panel_node) = surface_data.data_map.get::<Arc<Node>>() else { return };
let panel_item = PanelItem::from_node(panel_node); let Some(panel_item) = PanelItem::from_node(panel_node) else { return };
// core_surface.with_data(|core_surface_data| { panel_item.set_cursor();
// panel_item.resize();
// });
panel_item.set_cursor();
}
} }
pub fn resize(&self) { pub fn ack_resize(&self, xdg_config: Configure) {
self.core_surface.upgrade().unwrap().with_data(|data| { let Configure::Toplevel(config) = xdg_config else { return };
let _ = self let Some(size) = config.state.size else { return };
.node let Some(core_surface) = self.core_surface.upgrade() else { return };
.upgrade() core_surface.with_data(|data| data.size = Vector2::from([size.w as u32, size.h as u32]));
.unwrap() let _ = self
.send_remote_signal("resize", &serialize(data.size).unwrap()); .node
}); .upgrade()
.unwrap()
.send_remote_signal("resize", &serialize((size.w, size.h)).unwrap());
} }
pub fn set_cursor(&self) { pub fn set_cursor(&self) {
@@ -215,16 +223,12 @@ impl PanelItem {
} }
let mut data = serialize(()).unwrap(); let mut data = serialize(()).unwrap();
if let Some(cursor) = &*self.seat_data.cursor.lock() { let cursor = self.seat_data.cursor.lock();
let cursor = cursor.lock(); if let Some(cursor) = cursor.as_ref().map(|cursor| cursor.lock()) {
if let Some(core_surface) = cursor.core_surface.upgrade() { if let Some(core_surface) = cursor.core_surface.upgrade() {
if let Some(mapped_data) = &*core_surface.mapped_data.lock() { if let Some(mapped_data) = &*core_surface.mapped_data.lock() {
data = serialize((mapped_data.size, cursor.hotspot)).unwrap(); data = serialize((mapped_data.size, cursor.hotspot)).unwrap();
} else { }
return;
};
} else {
return;
} }
} }
@@ -241,109 +245,109 @@ impl PanelItem {
_calling_client: Arc<Client>, _calling_client: Arc<Client>,
_data: &[u8], _data: &[u8],
) -> Result<()> { ) -> Result<()> {
let panel_item = PanelItem::from_node(node); let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if *panel_item.seat_data.pointer_active.lock() { if !panel_item.seat_data.pointer_active() {
if let Some(core_surface) = panel_item.core_surface.upgrade() { return Ok(());
if let Some(pointer) = panel_item.seat_data.pointer() {
pointer.leave(0, &core_surface.wl_surface());
*panel_item.seat_data.pointer_active.lock() = false;
pointer.frame();
core_surface.flush_clients();
}
}
} }
let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
let Some(wl_surface) = core_surface.wl_surface() else { return Ok(()) };
let Some(pointer) = panel_item.seat_data.pointer() else { return Ok(()) };
pointer.leave(0, &wl_surface);
*panel_item.seat_data.pointer_active.lock() = false;
pointer.frame();
core_surface.flush_clients();
Ok(()) Ok(())
} }
fn pointer_motion_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> { fn pointer_motion_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(pointer) = panel_item.seat_data.pointer() { if !panel_item.seat_data.pointer_active() {
if let Some(core_surface) = panel_item.core_surface.upgrade() { return Ok(());
if let Some(size) = core_surface.with_data(|data| data.size) {
let mut position: Vector2<f64> = deserialize(data)?;
position.x = position.x.clamp(0.0, size.x as f64);
position.y = position.y.clamp(0.0, size.y as f64);
let mut pointer_active = panel_item.seat_data.pointer_active.lock();
if *pointer_active {
pointer.motion(0, position.x, position.y);
} else {
pointer.enter(0, &core_surface.wl_surface(), position.x, position.y);
*pointer_active = true;
}
pointer.frame();
core_surface.flush_clients();
}
}
}
} }
let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
let Some(wl_surface) = core_surface.wl_surface() else { return Ok(()) };
let Some(pointer) = panel_item.seat_data.pointer() else { return Ok(()) };
let Some(pointer_surface_size) =
core_surface.with_data(|data| data.size) else { return Ok(()) };
let mut position: Vector2<f64> = deserialize(data)?;
position.x = position.x.clamp(0.0, pointer_surface_size.x as f64);
position.y = position.y.clamp(0.0, pointer_surface_size.y as f64);
let mut pointer_active = panel_item.seat_data.pointer_active.lock();
if *pointer_active {
pointer.motion(0, position.x, position.y);
} else {
pointer.enter(0, &wl_surface, position.x, position.y);
*pointer_active = true;
}
pointer.frame();
core_surface.flush_clients();
Ok(()) Ok(())
} }
fn pointer_button_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> { fn pointer_button_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(pointer) = panel_item.seat_data.pointer() { if !panel_item.seat_data.pointer_active() {
if *panel_item.seat_data.pointer_active.lock() { return Ok(());
if let Some(core_surface) = panel_item.core_surface.upgrade() {
let (button, state): (u32, u32) = deserialize(data)?;
pointer.button(
0,
0,
button,
match state {
0 => ButtonState::Released,
1 => ButtonState::Pressed,
_ => {
bail!("Button state is out of bounds")
}
},
);
pointer.frame();
core_surface.flush_clients();
}
}
}
} }
let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
let Some(pointer) = panel_item.seat_data.pointer() else { return Ok(()) };
let (button, state): (u32, u32) = deserialize(data)?;
pointer.button(
0,
0,
button,
match state {
0 => ButtonState::Released,
1 => ButtonState::Pressed,
_ => {
bail!("Button state is out of bounds")
}
},
);
pointer.frame();
core_surface.flush_clients();
Ok(()) Ok(())
} }
fn pointer_scroll_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> { fn pointer_scroll_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if !panel_item.seat_data.pointer_active() {
return Ok(());
}
let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
let Some(pointer) = panel_item.seat_data.pointer() else { return Ok(()) };
#[derive(Deserialize)] #[derive(Deserialize)]
struct PointerScrollArgs { struct PointerScrollArgs {
axis_continuous: Vector2<f32>, axis_continuous: Vector2<f32>,
axis_discrete: Option<Vector2<f32>>, axis_discrete: Option<Vector2<f32>>,
} }
let args: PointerScrollArgs = deserialize(data)?; let args: Option<PointerScrollArgs> = deserialize(data)?;
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization {
if let Some(pointer) = panel_item.seat_data.pointer() { match args {
if *panel_item.seat_data.pointer_active.lock() { Some(args) => {
if let Some(core_surface) = panel_item.core_surface.upgrade() { pointer.axis(0, Axis::HorizontalScroll, args.axis_continuous.x as f64);
let flex = flexbuffers::Reader::get_root(data)?; pointer.axis(0, Axis::VerticalScroll, args.axis_continuous.y as f64);
if flex.flexbuffer_type().is_null() { if let Some(axis_discrete_vec) = args.axis_discrete {
pointer.axis_stop(0, Axis::HorizontalScroll); pointer.axis_discrete(Axis::HorizontalScroll, axis_discrete_vec.x as i32);
pointer.axis_stop(0, Axis::VerticalScroll); pointer.axis_discrete(Axis::VerticalScroll, axis_discrete_vec.y as i32);
} else {
pointer.axis(0, Axis::HorizontalScroll, args.axis_continuous.x as f64);
pointer.axis(0, Axis::VerticalScroll, args.axis_continuous.y as f64);
if let Some(axis_discrete_vec) = args.axis_discrete {
pointer.axis_discrete(
Axis::HorizontalScroll,
axis_discrete_vec.x as i32,
);
pointer.axis_discrete(
Axis::VerticalScroll,
axis_discrete_vec.y as i32,
);
}
}
pointer.frame();
core_surface.flush_clients();
}
} }
} }
} None => {
pointer.axis_stop(0, Axis::HorizontalScroll);
pointer.axis_stop(0, Axis::VerticalScroll);
}
};
pointer.frame();
core_surface.flush_clients();
Ok(()) Ok(())
} }
@@ -391,19 +395,18 @@ impl PanelItem {
} }
fn keyboard_activate_flex(node: &Node, keymap: &Keymap) -> Result<()> { fn keyboard_activate_flex(node: &Node, keymap: &Keymap) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(keyboard) = panel_item.seat_data.keyboard() { let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
if let Some(core_surface) = panel_item.core_surface.upgrade() { let Some(wl_surface) = core_surface.wl_surface() else { return Ok(()) };
let mut keyboard_info = panel_item.seat_data.keyboard_info.lock(); let Some(keyboard) = panel_item.seat_data.keyboard() else { return Ok(()) };
if keyboard_info.is_none() {
keyboard.enter(0, &core_surface.wl_surface(), vec![]); let mut keyboard_info = panel_item.seat_data.keyboard_info.lock();
keyboard.repeat_info(0, 0); if keyboard_info.is_none() {
} keyboard.enter(0, &wl_surface, vec![]);
keyboard_info.replace(KeyboardInfo::new(keymap)); keyboard.repeat_info(0, 0);
keyboard_info.as_ref().unwrap().keymap.send(keyboard)?;
}
}
} }
keyboard_info.replace(KeyboardInfo::new(keymap));
keyboard_info.as_ref().unwrap().keymap.send(keyboard)?;
Ok(()) Ok(())
} }
@@ -413,16 +416,15 @@ impl PanelItem {
_calling_client: Arc<Client>, _calling_client: Arc<Client>,
_data: &[u8], _data: &[u8],
) -> Result<()> { ) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(keyboard) = panel_item.seat_data.keyboard() { let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
if let Some(core_surface) = panel_item.core_surface.upgrade() { let Some(wl_surface) = core_surface.wl_surface() else { return Ok(()) };
let mut keyboard_info = panel_item.seat_data.keyboard_info.lock(); let Some(keyboard) = panel_item.seat_data.keyboard() else { return Ok(()) };
if keyboard_info.is_some() {
keyboard.leave(0, &core_surface.wl_surface()); let mut keyboard_info = panel_item.seat_data.keyboard_info.lock();
*keyboard_info = None; if keyboard_info.is_some() {
} keyboard.leave(0, &wl_surface);
} *keyboard_info = None;
}
} }
Ok(()) Ok(())
@@ -433,49 +435,48 @@ impl PanelItem {
_calling_client: Arc<Client>, _calling_client: Arc<Client>,
data: &[u8], data: &[u8],
) -> Result<()> { ) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(keyboard) = panel_item.seat_data.keyboard() { let Some(keyboard) = panel_item.seat_data.keyboard() else { return Ok(()) };
let mut keyboard_info = panel_item.seat_data.keyboard_info.lock();
if let Some(keyboard_info) = &mut *keyboard_info { let mut keyboard_info = panel_item.seat_data.keyboard_info.lock();
let (key, state): (u32, u32) = deserialize(data)?; if let Some(keyboard_info) = &mut *keyboard_info {
keyboard_info.process(key, state, keyboard)?; let (key, state): (u32, u32) = deserialize(data)?;
} keyboard_info.process(key, state, keyboard)?;
}
} }
Ok(()) Ok(())
} }
fn resize_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> { fn resize_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
if let ItemType::Panel(panel_item) = &node.item.get().unwrap().specialization { let Some(panel_item) = PanelItem::from_node(node) else { return Ok(()) };
if let Some(core_surface) = panel_item.core_surface.upgrade() { let Some(core_surface) = panel_item.core_surface.upgrade() else { return Ok(()) };
let size: Vector2<u32> = deserialize(data)?; let Some(wl_surface) = core_surface.wl_surface() else { return Ok(()) };
let size: Vector2<u32> = deserialize(data)?;
let toplevel_surface = core_surface let toplevel_surface = core_surface
.wayland_state() .wayland_state()
.lock() .lock()
.xdg_shell_state .xdg_shell_state
.toplevel_surfaces(|surfaces| { .toplevel_surfaces(|surfaces| {
surfaces surfaces
.iter() .iter()
.find(|surf| surf.wl_surface().clone() == core_surface.wl_surface()) .find(|surf| surf.wl_surface().clone() == wl_surface)
.cloned() .cloned()
}); });
if let Some(toplevel_surface) = toplevel_surface { if let Some(toplevel_surface) = toplevel_surface {
let mut size_set = false; let mut size_set = false;
toplevel_surface.with_pending_state(|state| { toplevel_surface.with_pending_state(|state| {
state.size = Some(Size::default()); state.size = Some(Size::default());
state.size.as_mut().unwrap().w = size.x as i32; state.size.as_mut().unwrap().w = size.x as i32;
state.size.as_mut().unwrap().h = size.y as i32; state.size.as_mut().unwrap().h = size.y as i32;
size_set = true; size_set = true;
}); });
if size_set { if size_set {
toplevel_surface.send_configure(); toplevel_surface.send_configure();
}
}
} }
} }
Ok(()) Ok(())
} }
} }

3
src/wayland/seat.rs
View File

@@ -121,6 +121,9 @@ impl SeatDataInner {
pub fn pointer(&self) -> Option<&WlPointer> { pub fn pointer(&self) -> Option<&WlPointer> {
self.pointer.get() self.pointer.get()
} }
pub fn pointer_active(&self) -> bool {
*self.pointer_active.lock()
}
pub fn keyboard(&self) -> Option<&WlKeyboard> { pub fn keyboard(&self) -> Option<&WlKeyboard> {
self.keyboard.get() self.keyboard.get()
} }

26
src/wayland/surface.rs
View File

@@ -10,7 +10,7 @@ use slog::Logger;
use smithay::{ use smithay::{
backend::renderer::{ backend::renderer::{
gles2::{Gles2Renderer, Gles2Texture}, gles2::{Gles2Renderer, Gles2Texture},
utils::{import_surface_tree, RendererSurfaceStateUserData}, utils::{import_surface_tree, on_commit_buffer_handler, RendererSurfaceStateUserData},
Texture, Texture,
}, },
desktop::utils::send_frames_surface_tree, desktop::utils::send_frames_surface_tree,
@@ -18,7 +18,7 @@ use smithay::{
reexports::wayland_server::{ reexports::wayland_server::{
self, protocol::wl_surface::WlSurface, Display, DisplayHandle, Resource, self, protocol::wl_surface::WlSurface, Display, DisplayHandle, Resource,
}, },
wayland::compositor::{self, SurfaceData, SurfaceUserData}, wayland::compositor::{self, SurfaceData},
}; };
use std::{ use std::{
sync::{Arc, Weak}, sync::{Arc, Weak},
@@ -128,17 +128,16 @@ impl CoreSurface {
on_mapped: F, on_mapped: F,
if_mapped: M, if_mapped: M,
) { ) {
// Avoid a panic in rare cases let Some(wl_surface) = self.wl_surface() else { return };
if self.wl_surface().data::<SurfaceUserData>().is_none() {
return;
}
// Let smithay handle buffer management (has to be done here as RendererSurfaceStates is not thread safe)
on_commit_buffer_handler(&wl_surface);
// Import all surface buffers into textures // Import all surface buffers into textures
if import_surface_tree(renderer, &self.wl_surface(), log).is_err() { if import_surface_tree(renderer, &wl_surface, log).is_err() {
return; return;
} }
let mapped = compositor::with_states(&self.wl_surface(), |data| { let mapped = compositor::with_states(&wl_surface, |data| {
data.data_map data.data_map
.get::<RendererSurfaceStateUserData>() .get::<RendererSurfaceStateUserData>()
.map(|surface_states| surface_states.borrow().wl_buffer().is_some()) .map(|surface_states| surface_states.borrow().wl_buffer().is_some())
@@ -170,7 +169,7 @@ impl CoreSurface {
if_mapped(data); if_mapped(data);
}); });
send_frames_surface_tree(&self.wl_surface(), &output, time, None, |_, _| { send_frames_surface_tree(&wl_surface, &output, time, None, |_, _| {
Some(output.clone()) Some(output.clone())
}); });
} }
@@ -198,15 +197,16 @@ impl CoreSurface {
self.state.upgrade().unwrap() self.state.upgrade().unwrap()
} }
pub fn wl_surface(&self) -> WlSurface { pub fn wl_surface(&self) -> Option<WlSurface> {
self.weak_surface.upgrade().unwrap() self.weak_surface.upgrade().ok()
} }
pub fn with_states<F, T>(&self, f: F) -> T pub fn with_states<F, T>(&self, f: F) -> Option<T>
where where
F: FnOnce(&SurfaceData) -> T, F: FnOnce(&SurfaceData) -> T,
{ {
compositor::with_states(&self.wl_surface(), f) self.wl_surface()
.map(|wl_surface| compositor::with_states(&wl_surface, f))
} }
pub fn with_data<F, T>(&self, f: F) -> Option<T> pub fn with_data<F, T>(&self, f: F) -> Option<T>

49
src/wayland/xdg_shell.rs
View File

@@ -2,7 +2,7 @@ use std::sync::Arc;
use crate::nodes::Node; use crate::nodes::Node;
use super::{panel_item::PanelItem, state::WaylandState, surface::CoreSurface}; use super::{panel_item::PanelItem, state::WaylandState};
use smithay::{ use smithay::{
delegate_xdg_shell, delegate_xdg_shell,
reexports::{ reexports::{
@@ -37,29 +37,30 @@ impl XdgShellHandler for WaylandState {
surface.send_configure(); surface.send_configure();
} }
fn ack_configure(&mut self, surface: WlSurface, configure: Configure) { fn ack_configure(&mut self, surface: WlSurface, configure: Configure) {
match configure { // let size = match configure {
Configure::Toplevel(config) => { // Configure::Toplevel(config) => config.state.size,
if let Some(size) = config.state.size { // Configure::Popup(_) => return,
compositor::with_states(&surface, |data| { // };
if let Some(panel_node) = data.data_map.get::<Arc<Node>>() { // let core_surface = match configure {
if let Some(core_surface) = data.data_map.get::<Arc<CoreSurface>>() { // Configure::Toplevel(config) => {
let panel_item = PanelItem::from_node(panel_node); // .and_then(|panel| panel.core_surface())
let has_data = core_surface // }
.with_data(|data| { // Configure::Popup(_) => return,
data.size.x = size.w as u32; // };
data.size.y = size.h as u32; let Some(panel_item_node) = compositor::with_states(&surface, |data| {
}) data.data_map.get::<Arc<Node>>().cloned()
.is_some(); }) else { return };
if has_data { let Some(panel_item) = PanelItem::from_node(&panel_item_node) else { return };
panel_item.resize(); panel_item.ack_resize(configure);
}
} // let has_data = core_surface
} // .with_data(|data| {
}) // data.size.x = size.w as u32;
} // data.size.y = size.h as u32;
} // })
Configure::Popup(_) => (), // .is_some();
} // if has_data {
// }
} }
fn new_popup(&mut self, _surface: PopupSurface, _positioner: PositionerState) {} fn new_popup(&mut self, _surface: PopupSurface, _positioner: PositionerState) {}