waydeer/layer-shika
1
0
Fork 0
mirror of https://codeberg.org/waydeer/layer-shika.git synced 2025-11-17 23:14:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

refactor: minor surface state changes

Browse source
This commit is contained in:
drendog 2025-11-09 15:58:28 +01:00
parent bf43337a30
commit c3c2690e84
Signed by: dwenya
GPG key ID: 8DD77074645332D0
1 changed files with 54 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

113
adapters/src/wayland/surfaces/surface_state.rs
View file

@ -1,5 +1,4 @@
use std::rc::Rc; use std::rc::Rc;
use std::cell::RefCell;
use super::surface_builder::WindowStateBuilder; use super::surface_builder::WindowStateBuilder;
use super::dimensions::SurfaceDimensionsExt; use super::dimensions::SurfaceDimensionsExt;
use super::popup_manager::PopupManager; use super::popup_manager::PopupManager;
@ -20,6 +19,7 @@ use slint_interpreter::{ComponentInstance, CompilationResult};
use smithay_client_toolkit::reexports::protocols_wlr::layer_shell::v1::client::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1; use smithay_client_toolkit::reexports::protocols_wlr::layer_shell::v1::client::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1;
use wayland_client::{protocol::wl_surface::WlSurface, Proxy}; use wayland_client::{protocol::wl_surface::WlSurface, Proxy};
use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1; use wayland_protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
use std::cell::RefCell;
pub struct SharedPointerSerial { pub struct SharedPointerSerial {
serial: RefCell<u32>, serial: RefCell<u32>,
@ -60,33 +60,6 @@ enum ActiveWindow {
Popup(usize), Popup(usize),
} }
struct MutableWindowState {
size: PhysicalSize,
logical_size: PhysicalSize,
output_size: PhysicalSize,
current_pointer_position: LogicalPosition,
last_pointer_serial: u32,
shared_pointer_serial: Option<Rc<SharedPointerSerial>>,
scale_factor: f32,
active_window: Option<ActiveWindow>,
}
impl MutableWindowState {
#[allow(clippy::cast_possible_truncation)]
fn set_pointer_position(&mut self, physical_x: f64, physical_y: f64, fractional_scale: bool) {
let logical_position = if fractional_scale {
LogicalPosition::new(physical_x as f32, physical_y as f32)
} else {
let scale_factor = self.scale_factor;
LogicalPosition::new(
(physical_x / f64::from(scale_factor)) as f32,
(physical_y / f64::from(scale_factor)) as f32,
)
};
self.current_pointer_position = logical_position;
}
}
pub struct WindowState { pub struct WindowState {
component_instance: ComponentInstance, component_instance: ComponentInstance,
compilation_result: Option<Rc<CompilationResult>>, compilation_result: Option<Rc<CompilationResult>>,
@ -100,7 +73,14 @@ pub struct WindowState {
height: u32, height: u32,
exclusive_zone: i32, exclusive_zone: i32,
popup_manager: Option<Rc<PopupManager>>, popup_manager: Option<Rc<PopupManager>>,
mutable_state: RefCell<MutableWindowState>, size: PhysicalSize,
logical_size: PhysicalSize,
output_size: PhysicalSize,
current_pointer_position: LogicalPosition,
last_pointer_serial: u32,
shared_pointer_serial: Option<Rc<SharedPointerSerial>>,
scale_factor: f32,
active_window: Option<ActiveWindow>,
} }
impl WindowState { impl WindowState {
@ -171,7 +151,6 @@ impl WindowState {
height: builder.height, height: builder.height,
exclusive_zone: builder.exclusive_zone, exclusive_zone: builder.exclusive_zone,
popup_manager: None, popup_manager: None,
mutable_state: RefCell::new(MutableWindowState {
size: builder.size.unwrap_or_default(), size: builder.size.unwrap_or_default(),
logical_size: PhysicalSize::default(), logical_size: PhysicalSize::default(),
output_size: builder.output_size.unwrap_or_default(), output_size: builder.output_size.unwrap_or_default(),
@ -180,7 +159,6 @@ impl WindowState {
shared_pointer_serial: None, shared_pointer_serial: None,
scale_factor: builder.scale_factor, scale_factor: builder.scale_factor,
active_window: None, active_window: None,
}),
}) })
} }
@ -196,10 +174,9 @@ impl WindowState {
#[allow(clippy::cast_precision_loss)] #[allow(clippy::cast_precision_loss)]
fn configure_slint_window(&self, dimensions: &SurfaceDimensions, mode: ScalingMode) { fn configure_slint_window(&self, dimensions: &SurfaceDimensions, mode: ScalingMode) {
let state = self.mutable_state.borrow();
match mode { match mode {
ScalingMode::FractionalWithViewport => { ScalingMode::FractionalWithViewport => {
self.window.set_scale_factor(state.scale_factor); self.window.set_scale_factor(self.scale_factor);
self.window self.window
.set_size(slint::WindowSize::Logical(slint::LogicalSize::new( .set_size(slint::WindowSize::Logical(slint::LogicalSize::new(
dimensions.logical_width as f32, dimensions.logical_width as f32,
@ -215,7 +192,7 @@ impl WindowState {
))); )));
} }
ScalingMode::Integer => { ScalingMode::Integer => {
self.window.set_scale_factor(state.scale_factor); self.window.set_scale_factor(self.scale_factor);
self.window self.window
.set_size(slint::WindowSize::Physical(dimensions.physical_size())); .set_size(slint::WindowSize::Physical(dimensions.physical_size()));
} }
@ -271,25 +248,31 @@ impl WindowState {
info!("Window physical size: {:?}", self.window.size()); info!("Window physical size: {:?}", self.window.size());
let mut state = self.mutable_state.borrow_mut(); self.size = dimensions.physical_size();
state.size = dimensions.physical_size(); self.logical_size = dimensions.logical_size();
state.logical_size = dimensions.logical_size();
self.window.request_redraw(); self.window.request_redraw();
} }
#[allow(clippy::cast_possible_truncation)] #[allow(clippy::cast_possible_truncation)]
pub fn set_current_pointer_position(&mut self, physical_x: f64, physical_y: f64) { pub fn set_current_pointer_position(&mut self, physical_x: f64, physical_y: f64) {
let has_fractional_scale = self.fractional_scale.is_some(); let has_fractional_scale = self.fractional_scale.is_some();
let mut state = self.mutable_state.borrow_mut(); let logical_position = if has_fractional_scale {
state.set_pointer_position(physical_x, physical_y, has_fractional_scale); LogicalPosition::new(physical_x as f32, physical_y as f32)
} else {
LogicalPosition::new(
(physical_x / f64::from(self.scale_factor)) as f32,
(physical_y / f64::from(self.scale_factor)) as f32,
)
};
self.current_pointer_position = logical_position;
} }
pub fn size(&self) -> PhysicalSize { pub const fn size(&self) -> PhysicalSize {
self.mutable_state.borrow().size self.size
} }
pub fn current_pointer_position(&self) -> LogicalPosition { pub const fn current_pointer_position(&self) -> LogicalPosition {
self.mutable_state.borrow().current_pointer_position self.current_pointer_position
} }
pub(crate) fn window(&self) -> Rc<FemtoVGWindow> { pub(crate) fn window(&self) -> Rc<FemtoVGWindow> {
@ -305,14 +288,14 @@ impl WindowState {
} }
pub fn set_output_size(&mut self, output_size: PhysicalSize) { pub fn set_output_size(&mut self, output_size: PhysicalSize) {
self.mutable_state.borrow_mut().output_size = output_size; self.output_size = output_size;
if let Some(popup_manager) = &self.popup_manager { if let Some(popup_manager) = &self.popup_manager {
popup_manager.update_output_size(output_size); popup_manager.update_output_size(output_size);
} }
} }
pub fn output_size(&self) -> PhysicalSize { pub const fn output_size(&self) -> PhysicalSize {
self.mutable_state.borrow().output_size self.output_size
} }
pub const fn component_instance(&self) -> &ComponentInstance { pub const fn component_instance(&self) -> &ComponentInstance {
@ -331,41 +314,40 @@ impl WindowState {
#[allow(clippy::cast_precision_loss)] #[allow(clippy::cast_precision_loss)]
pub fn update_scale_factor(&mut self, scale_120ths: u32) { pub fn update_scale_factor(&mut self, scale_120ths: u32) {
let new_scale_factor = scale_120ths as f32 / 120.0; let new_scale_factor = scale_120ths as f32 / 120.0;
let old_scale_factor = self.scale_factor(); let old_scale_factor = self.scale_factor;
info!( info!(
"Updating scale factor from {} to {} ({}x)", "Updating scale factor from {} to {} ({}x)",
old_scale_factor, new_scale_factor, scale_120ths old_scale_factor, new_scale_factor, scale_120ths
); );
self.mutable_state.borrow_mut().scale_factor = new_scale_factor; self.scale_factor = new_scale_factor;
if let Some(popup_manager) = &self.popup_manager { if let Some(popup_manager) = &self.popup_manager {
popup_manager.update_scale_factor(new_scale_factor); popup_manager.update_scale_factor(new_scale_factor);
} }
let current_logical_size = self.mutable_state.borrow().logical_size; let current_logical_size = self.logical_size;
if current_logical_size.width > 0 && current_logical_size.height > 0 { if current_logical_size.width > 0 && current_logical_size.height > 0 {
self.update_size(current_logical_size.width, current_logical_size.height); self.update_size(current_logical_size.width, current_logical_size.height);
} }
} }
pub fn scale_factor(&self) -> f32 { pub const fn scale_factor(&self) -> f32 {
self.mutable_state.borrow().scale_factor self.scale_factor
} }
pub fn last_pointer_serial(&self) -> u32 { pub const fn last_pointer_serial(&self) -> u32 {
self.mutable_state.borrow().last_pointer_serial self.last_pointer_serial
} }
pub fn set_last_pointer_serial(&mut self, serial: u32) { pub fn set_last_pointer_serial(&mut self, serial: u32) {
let mut state = self.mutable_state.borrow_mut(); self.last_pointer_serial = serial;
state.last_pointer_serial = serial; if let Some(ref shared_serial) = self.shared_pointer_serial {
if let Some(ref shared_serial) = state.shared_pointer_serial {
shared_serial.update(serial); shared_serial.update(serial);
} }
} }
pub fn set_shared_pointer_serial(&mut self, shared_serial: Rc<SharedPointerSerial>) { pub fn set_shared_pointer_serial(&mut self, shared_serial: Rc<SharedPointerSerial>) {
self.mutable_state.borrow_mut().shared_pointer_serial = Some(shared_serial); self.shared_pointer_serial = Some(shared_serial);
} }
pub fn set_popup_manager(&mut self, popup_manager: Rc<PopupManager>) { pub fn set_popup_manager(&mut self, popup_manager: Rc<PopupManager>) {
@ -376,24 +358,22 @@ impl WindowState {
let surface_id = surface.id(); let surface_id = surface.id();
if (**self.surface.inner()).id() == surface_id { if (**self.surface.inner()).id() == surface_id {
self.mutable_state.borrow_mut().active_window = Some(ActiveWindow::Main); self.active_window = Some(ActiveWindow::Main);
return; return;
} }
if let Some(popup_manager) = &self.popup_manager { if let Some(popup_manager) = &self.popup_manager {
if let Some(popup_key) = popup_manager.find_popup_key_by_surface_id(&surface_id) { if let Some(popup_key) = popup_manager.find_popup_key_by_surface_id(&surface_id) {
self.mutable_state.borrow_mut().active_window = self.active_window = Some(ActiveWindow::Popup(popup_key));
Some(ActiveWindow::Popup(popup_key));
return; return;
} }
} }
self.mutable_state.borrow_mut().active_window = None; self.active_window = None;
} }
pub fn dispatch_to_active_window(&self, event: WindowEvent) { pub fn dispatch_to_active_window(&self, event: WindowEvent) {
let active_window = self.mutable_state.borrow().active_window; match self.active_window {
match active_window {
Some(ActiveWindow::Main) => { Some(ActiveWindow::Main) => {
self.window.window().dispatch_event(event); self.window.window().dispatch_event(event);
} }
@ -438,13 +418,12 @@ impl WindowState {
} }
pub fn clear_active_window(&mut self) { pub fn clear_active_window(&mut self) {
self.mutable_state.borrow_mut().active_window = None; self.active_window = None;
} }
pub fn clear_active_window_if_popup(&mut self, popup_key: usize) { pub fn clear_active_window_if_popup(&mut self, popup_key: usize) {
let mut state = self.mutable_state.borrow_mut(); if self.active_window == Some(ActiveWindow::Popup(popup_key)) {
if state.active_window == Some(ActiveWindow::Popup(popup_key)) { self.active_window = None;
state.active_window = None;
} }
} }