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

refactor(panel item): nuke unnecessary functions

Browse Source
This commit is contained in:
Nova
2023-08-24 04:39:26 -04:00
parent 707e56cb6f
commit 237b084a65
3 changed files with 41 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/nodes/items/panel.rs
View File

@@ -212,19 +212,8 @@ pub trait Backend: Send + Sync + 'static {
fn close_toplevel(&self);
fn auto_size_toplevel(&self);
fn set_toplevel_size(&self, size: Vector2<u32>);
fn toplevel_maximize(&self);
fn toplevel_unmaximize(&self);
fn toplevel_fullscreen(&self);
fn toplevel_unfullscreen(&self);
fn set_toplevel_tiling(&self, up: bool, down: bool, left: bool, right: bool);
fn set_toplevel_bounds(&self, bounds: Option<Vector2<u32>>);
fn set_toplevel_focused_visuals(&self, focused: bool);
fn set_maximize_enabled(&self, enabled: bool);
fn set_minimize_enabled(&self, enabled: bool);
fn set_fullscreen_enabled(&self, enabled: bool);
fn set_window_menu_enabled(&self, enabled: bool);
fn pointer_motion(&self, surface: &SurfaceID, position: Vector2<f32>);
fn pointer_button(&self, surface: &SurfaceID, button: u32, pressed: bool);
fn pointer_scroll(
@@ -234,6 +223,7 @@ pub trait Backend: Send + Sync + 'static {
scroll_steps: Option<Vector2<f32>>,
);
fn keyboard_keymap(&self, surface: &SurfaceID, keymap_id: &str);
fn keyboard_key(&self, surface: &SurfaceID, key: u32, state: bool);
}
@@ -299,33 +289,12 @@ impl<B: Backend + ?Sized> PanelItem<B> {
node.add_local_signal("close_toplevel", Self::close_toplevel_flex);
node.add_local_signal("auto_size_toplevel", Self::auto_size_toplevel_flex);
node.add_local_signal("set_toplevel_size_changed", Self::set_toplevel_size_changed);
node.add_local_signal("toplevel_maximize", Self::toplevel_maximize_flex);
node.add_local_signal("toplevel_unmaximize", Self::toplevel_unmaximize_flex);
node.add_local_signal("toplevel_fullscreen", Self::toplevel_fullscreen_flex);
node.add_local_signal("toplevel_unfullscreen", Self::toplevel_unfullscreen_flex);
node.add_local_signal("set_toplevel_tiling", Self::set_toplevel_tiling_flex);
node.add_local_signal("set_toplevel_bounds", Self::set_toplevel_bounds_flex);
node.add_local_signal("set_maximize_enabled", Self::set_maximize_enabled_flex);
node.add_local_signal("set_minimize_enabled", Self::set_minimize_enabled_flex);
node.add_local_signal("set_fullscreen_enabled", Self::set_fullscreen_enabled_flex);
node.add_local_signal(
"set_window_menu_enabled",
Self::set_window_menu_enabled_flex,
);
node.add_local_signal("pointer_motion", Self::pointer_motion_flex);
node.add_local_signal("pointer_button", Self::pointer_button_flex);
node.add_local_signal("pointer_scroll", Self::pointer_scroll_flex);
// node.add_local_signal(
// "keyboard_set_keymap_string",
// Self::keyboard_set_keymap_string_flex,
// );
// node.add_local_signal(
// "keyboard_set_keymap_names",
// Self::keyboard_set_keymap_names_flex,
// );
node.add_local_signal("keyboard_keymap", Self::keyboard_keymap_flex);
node.add_local_signal("keyboard_key", Self::keyboard_key_flex);
(node, panel_item)
@@ -354,9 +323,9 @@ impl<B: Backend + ?Sized> PanelItem<B> {
let Some(node) = self.node.upgrade() else {return};
let _ = node.send_remote_signal("toplevel_window_menu", serialize(offset).unwrap());
}
pub fn recommend_toplevel_state(&self, state: ToplevelState) {
pub fn toplevel_fullscreen_active(&self, active: bool) {
let Some(node) = self.node.upgrade() else {return};
let _ = node.send_remote_signal("recommend_toplevel_state", serialize(state).unwrap());
let _ = node.send_remote_signal("toplevel_fullscreen_active", serialize(active).unwrap());
}
pub fn toplevel_move_request(&self) {
let Some(node) = self.node.upgrade() else {return};
@@ -442,26 +411,6 @@ impl<B: Backend + ?Sized> PanelItem<B> {
flex_no_args!(close_toplevel_flex, close_toplevel);
flex_no_args!(auto_size_toplevel_flex, auto_size_toplevel);
flex_deserialize!(set_toplevel_size_changed, set_toplevel_size);
flex_no_args!(toplevel_maximize_flex, toplevel_maximize);
flex_no_args!(toplevel_unmaximize_flex, toplevel_unmaximize);
flex_no_args!(toplevel_fullscreen_flex, toplevel_fullscreen);
flex_no_args!(toplevel_unfullscreen_flex, toplevel_unfullscreen);
flex_deserialize!(set_toplevel_bounds_flex, set_toplevel_bounds);
fn set_toplevel_tiling_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let (up, down, left, right) = deserialize(message.as_ref())?;
panel_item.set_toplevel_tiling(up, down, left, right);
Ok(())
}
flex_deserialize!(set_maximize_enabled_flex, set_maximize_enabled);
flex_deserialize!(set_minimize_enabled_flex, set_minimize_enabled);
flex_deserialize!(set_fullscreen_enabled_flex, set_fullscreen_enabled);
flex_deserialize!(set_window_menu_enabled_flex, set_window_menu_enabled);
fn pointer_motion_flex(
node: &Node,
@@ -511,6 +460,19 @@ impl<B: Backend + ?Sized> PanelItem<B> {
Ok(())
}
fn keyboard_keymap_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let (surface_id, keymap): (SurfaceID, &str) = deserialize(message.as_ref())?;
debug!(?surface_id, keymap, "Set keyboard keymap");
panel_item.keyboard_keymap(&surface_id, keymap);
Ok(())
}
fn keyboard_key_flex(
node: &Node,
_calling_client: Arc<Client>,
@@ -558,40 +520,9 @@ impl<B: Backend + ?Sized> Backend for PanelItem<B> {
fn set_toplevel_size(&self, size: Vector2<u32>) {
self.backend.set_toplevel_size(size)
}
fn set_toplevel_tiling(&self, up: bool, down: bool, left: bool, right: bool) {
self.backend.set_toplevel_tiling(up, down, left, right)
}
fn set_toplevel_bounds(&self, bounds: Option<Vector2<u32>>) {
self.backend.set_toplevel_bounds(bounds)
}
fn set_toplevel_focused_visuals(&self, focused: bool) {
self.backend.set_toplevel_focused_visuals(focused)
}
fn toplevel_maximize(&self) {
self.backend.toplevel_maximize()
}
fn toplevel_unmaximize(&self) {
self.backend.toplevel_unmaximize()
}
fn toplevel_fullscreen(&self) {
self.backend.toplevel_fullscreen()
}
fn toplevel_unfullscreen(&self) {
self.backend.toplevel_unfullscreen()
}
fn set_maximize_enabled(&self, enabled: bool) {
self.backend.set_maximize_enabled(enabled)
}
fn set_minimize_enabled(&self, enabled: bool) {
self.backend.set_minimize_enabled(enabled)
}
fn set_fullscreen_enabled(&self, enabled: bool) {
self.backend.set_fullscreen_enabled(enabled)
}
fn set_window_menu_enabled(&self, enabled: bool) {
self.backend.set_window_menu_enabled(enabled)
}
fn pointer_motion(&self, surface: &SurfaceID, position: Vector2<f32>) {
self.backend.pointer_motion(surface, position)
@@ -609,6 +540,9 @@ impl<B: Backend + ?Sized> Backend for PanelItem<B> {
.pointer_scroll(surface, scroll_distance, scroll_steps)
}
fn keyboard_keymap(&self, surface: &SurfaceID, keymap_id: &str) {
self.backend.keyboard_keymap(surface, keymap_id)
}
fn keyboard_key(&self, surface: &SurfaceID, key: u32, state: bool) {
self.backend.keyboard_key(surface, key, state)
}

118
src/wayland/xdg_shell.rs
View File

@@ -9,7 +9,6 @@ use crate::{
drawable::model::ModelPart,
items::panel::{
Backend, ChildInfo, Geometry, PanelItem, PanelItemInitData, SurfaceID, ToplevelInfo,
ToplevelState,
},
Node,
},
@@ -25,9 +24,7 @@ use smithay::reexports::{
xdg_popup::{self, XdgPopup},
xdg_positioner::{self, Anchor, ConstraintAdjustment, Gravity, XdgPositioner},
xdg_surface::{self, XdgSurface},
xdg_toplevel::{
self, ResizeEdge, XdgToplevel, EVT_CONFIGURE_BOUNDS_SINCE, EVT_WM_CAPABILITIES_SINCE,
},
xdg_toplevel::{self, ResizeEdge, XdgToplevel, EVT_WM_CAPABILITIES_SINCE},
xdg_wm_base::{self, XdgWmBase},
},
wayland_server::{
@@ -632,26 +629,19 @@ impl Dispatch<XdgToplevel, Mutex<ToplevelData>, WaylandState> for WaylandState {
data.lock().min_size = (width > 1 || height > 1)
.then_some(Vector2::from([width as u32, height as u32]));
}
xdg_toplevel::Request::SetMaximized => {
let Some(panel_item) = data.lock().panel_item() else {return};
panel_item.recommend_toplevel_state(ToplevelState::Maximized);
}
xdg_toplevel::Request::UnsetMaximized => {
let Some(panel_item) = data.lock().panel_item() else {return};
panel_item.recommend_toplevel_state(ToplevelState::UnMaximized);
}
xdg_toplevel::Request::SetMaximized => {}
xdg_toplevel::Request::UnsetMaximized => {}
xdg_toplevel::Request::SetFullscreen { output: _ } => {
let Some(panel_item) = data.lock().panel_item() else {return};
panel_item.recommend_toplevel_state(ToplevelState::Fullscreen);
panel_item.backend.toplevel_state.lock().fullscreen = true;
panel_item.backend.configure(None);
}
xdg_toplevel::Request::UnsetFullscreen => {
let Some(panel_item) = data.lock().panel_item() else {return};
panel_item.recommend_toplevel_state(ToplevelState::UnFullscreen);
}
xdg_toplevel::Request::SetMinimized => {
let Some(panel_item) = data.lock().panel_item() else {return};
panel_item.recommend_toplevel_state(ToplevelState::Minimized);
panel_item.backend.toplevel_state.lock().fullscreen = false;
panel_item.backend.configure(None);
}
xdg_toplevel::Request::SetMinimized => {}
xdg_toplevel::Request::Destroy => {
debug!(?xdg_toplevel, "Destroy XDG Toplevel");
let Some(panel_item) = data.lock().panel_item() else {return};
@@ -777,16 +767,7 @@ impl Dispatch<XdgPopup, Mutex<PopupData>, WaylandState> for WaylandState {
struct XdgToplevelState {
fullscreen: bool,
maximized: bool,
activated: bool,
tiled_up: bool,
tiled_down: bool,
tiled_left: bool,
tiled_right: bool,
capability_window_menu: bool,
capability_maximize: bool,
capability_fullscreen: bool,
capability_minimize: bool,
}
pub struct XDGBackend {
@@ -813,16 +794,7 @@ impl XDGBackend {
toplevel_wl_surface,
toplevel_state: Mutex::new(XdgToplevelState {
fullscreen: false,
maximized: false,
activated: false,
tiled_up: false,
tiled_down: false,
tiled_left: false,
tiled_right: false,
capability_window_menu: false,
capability_maximize: false,
capability_fullscreen: false,
capability_minimize: false,
}),
popups: Mutex::new(FxHashMap::default()),
cursor,
@@ -874,29 +846,14 @@ impl XDGBackend {
self.flush_client();
}
fn states(&self) -> Vec<u32> {
let mut states = Vec::new();
let mut states = vec![1, 5, 6, 7, 8]; // maximized always and tiled
let toplevel_state = self.toplevel_state.lock();
if toplevel_state.maximized {
states.push(1);
}
if toplevel_state.fullscreen {
states.push(2);
}
if toplevel_state.activated {
states.push(4);
}
if toplevel_state.tiled_left {
states.push(5);
}
if toplevel_state.tiled_right {
states.push(6);
}
if toplevel_state.tiled_up {
states.push(7);
}
if toplevel_state.tiled_down {
states.push(8);
}
states
}
@@ -1036,63 +993,10 @@ impl Backend for XDGBackend {
fn set_toplevel_size(&self, size: Vector2<u32>) {
self.configure(Some(size));
}
fn toplevel_maximize(&self) {
self.toplevel_state.lock().maximized = true;
self.configure(None);
}
fn toplevel_unmaximize(&self) {
self.toplevel_state.lock().maximized = false;
self.configure(None);
}
fn toplevel_fullscreen(&self) {
self.toplevel_state.lock().fullscreen = true;
self.configure(None);
}
fn toplevel_unfullscreen(&self) {
self.toplevel_state.lock().fullscreen = false;
self.configure(None);
}
fn set_toplevel_focused_visuals(&self, focused: bool) {
self.toplevel_state.lock().activated = focused;
self.configure(None);
}
fn set_toplevel_tiling(&self, up: bool, down: bool, left: bool, right: bool) {
self.toplevel_state.lock().tiled_up = up;
self.toplevel_state.lock().tiled_down = down;
self.toplevel_state.lock().tiled_left = left;
self.toplevel_state.lock().tiled_right = right;
self.configure(None);
}
fn set_toplevel_bounds(&self, bounds: Option<Vector2<u32>>) {
let Ok(xdg_toplevel) = self.toplevel.upgrade() else {return};
let Some(xdg_surface) = self.toplevel_xdg_surface() else {return};
if xdg_toplevel.version() <= EVT_CONFIGURE_BOUNDS_SINCE {
return;
}
xdg_toplevel.configure_bounds(
bounds.map(|b| b.x as i32).unwrap_or_default(),
bounds.map(|b| b.y as i32).unwrap_or_default(),
);
xdg_surface.configure(SERIAL_COUNTER.inc());
self.flush_client();
}
fn set_maximize_enabled(&self, enabled: bool) {
self.toplevel_state.lock().capability_maximize = enabled;
self.configure(None);
}
fn set_minimize_enabled(&self, enabled: bool) {
self.toplevel_state.lock().capability_minimize = enabled;
self.configure(None);
}
fn set_fullscreen_enabled(&self, enabled: bool) {
self.toplevel_state.lock().capability_fullscreen = enabled;
self.configure(None);
}
fn set_window_menu_enabled(&self, enabled: bool) {
self.toplevel_state.lock().capability_window_menu = enabled;
self.configure(None);
}
fn pointer_motion(&self, surface: &SurfaceID, position: Vector2<f32>) {
let Some(surface) = self.wl_surface_from_id(surface) else {return};
@@ -1135,4 +1039,8 @@ impl Backend for XDGBackend {
},
)
}
fn keyboard_keymap(&self, _surface: &SurfaceID, _keymap_id: &str) {
todo!()
}
}

43
src/wayland/xwayland.rs
View File

@@ -5,9 +5,7 @@ use super::{
use crate::{
nodes::{
drawable::model::ModelPart,
items::panel::{
Backend, Geometry, PanelItem, PanelItemInitData, SurfaceID, ToplevelInfo, ToplevelState,
},
items::panel::{Backend, Geometry, PanelItem, PanelItemInitData, SurfaceID, ToplevelInfo},
},
wayland::surface::CoreSurface,
};
@@ -237,25 +235,15 @@ impl XwmHandler for XWaylandHandler {
panel_item.toplevel_resize_request(up, down, left, right)
}
fn maximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let Some(panel_item) = self.panel_item(&window) else {return};
panel_item.recommend_toplevel_state(ToplevelState::Maximized);
}
fn unmaximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let Some(panel_item) = self.panel_item(&window) else {return};
panel_item.recommend_toplevel_state(ToplevelState::UnMaximized);
}
fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
let _ = window.set_fullscreen(true);
let Some(panel_item) = self.panel_item(&window) else {return};
panel_item.recommend_toplevel_state(ToplevelState::Fullscreen);
panel_item.toplevel_fullscreen_active(true);
}
fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
let _ = window.set_fullscreen(false);
let Some(panel_item) = self.panel_item(&window) else {return};
panel_item.recommend_toplevel_state(ToplevelState::UnFullscreen);
}
fn minimize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let Some(panel_item) = self.panel_item(&window) else {return};
panel_item.recommend_toplevel_state(ToplevelState::Minimized);
panel_item.toplevel_fullscreen_active(true);
}
}
@@ -385,27 +373,9 @@ impl Backend for X11Backend {
size: (size.x as i32, size.y as i32).into(),
}));
}
fn toplevel_maximize(&self) {
let _ = self.toplevel.set_maximized(true);
}
fn toplevel_unmaximize(&self) {
let _ = self.toplevel.set_maximized(false);
}
fn toplevel_fullscreen(&self) {
let _ = self.toplevel.set_fullscreen(true);
}
fn toplevel_unfullscreen(&self) {
let _ = self.toplevel.set_fullscreen(false);
}
fn set_toplevel_tiling(&self, _up: bool, _down: bool, _left: bool, _right: bool) {}
fn set_toplevel_bounds(&self, _bounds: Option<Vector2<u32>>) {}
fn set_toplevel_focused_visuals(&self, focused: bool) {
let _ = self.toplevel.set_activated(focused);
}
fn set_maximize_enabled(&self, _enabled: bool) {}
fn set_minimize_enabled(&self, _enabled: bool) {}
fn set_fullscreen_enabled(&self, _enabled: bool) {}
fn set_window_menu_enabled(&self, _enabled: bool) {}
fn apply_surface_material(&self, surface: SurfaceID, model_part: &Arc<ModelPart>) {
let Some(wl_surface) = self.wl_surface_from_id(&surface) else {return};
@@ -445,6 +415,9 @@ impl Backend for X11Backend {
)
}
fn keyboard_keymap(&self, surface: &SurfaceID, keymap_id: &str) {
todo!()
}
fn keyboard_key(&self, surface: &SurfaceID, key: u32, state: bool) {
let Some(surface) = self.wl_surface_from_id(surface) else {return};
self.seat.keyboard_event(