bhrebec/xwayland-satellite
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use fractional scaling when setting scale through xsettings

Browse source 
Fixes #168
This commit is contained in:
Shawn Wallace 2025-06-19 17:02:42 -04:00
parent 799027d1ae
commit b98fa84524
6 changed files with 269 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/server/dispatch.rs
View file

@ -1350,11 +1350,11 @@ impl<C: XConnection> GlobalDispatch<WlOutput, Global> for ServerState<C> {
(
server,
client,
event::OutputScaleFactor(1),
event::OutputScaleFactor::Output(1),
event::OutputDimensions::default(),
),
);
state.output_scales_updated = true;
state.updated_outputs.push(entity);
}
}
global_dispatch_with_events!(WlDrmServer, WlDrmClient);

109
src/server/event.rs
View file

@ -44,12 +44,15 @@ use wayland_server::protocol::{
wl_seat::WlSeat, wl_touch::WlTouch,
};
#[derive(Copy, Clone)]
pub(super) struct SurfaceScaleFactor(pub f64);
#[derive(hecs::Bundle)]
pub(super) struct SurfaceBundle {
pub client: client::wl_surface::WlSurface,
pub server: WlSurface,
pub scale: SurfaceScaleFactor,
pub viewport: WpViewport,
pub scale: SurfaceScaleFactor,
}
#[derive(Debug)]
@ -86,12 +89,22 @@ impl Event for SurfaceEvents {
wp_fractional_scale_v1::Event::PreferredScale { scale } => {
let entity = state.world.entity(target).unwrap();
let factor = scale as f64 / 120.0;
entity.get::<&mut SurfaceScaleFactor>().unwrap().0 = factor;
log::debug!(
debug!(
"{} scale factor: {}",
entity.get::<&WlSurface>().unwrap().id(),
factor
);
entity.get::<&mut SurfaceScaleFactor>().unwrap().0 = factor;
if let Some(OnOutput(output)) = entity.get::<&OnOutput>().as_deref().copied() {
if update_output_scale(
state.world.query_one(output).unwrap(),
OutputScaleFactor::Fractional(factor),
) {
state.updated_outputs.push(output);
}
}
if entity.has::<WindowData>() {
update_surface_viewport(state.world.query_one(target).unwrap());
}
@ -126,11 +139,6 @@ impl SurfaceEvents {
surface.enter(&output);
let on_output = OnOutput(output_entity);
if state.fractional_scale.is_none() {
data.get::<&mut SurfaceScaleFactor>().unwrap().0 =
output_data.get::<&OutputScaleFactor>().unwrap().0 as f64;
}
debug!("{} entered {}", surface.id(), output.id());
let mut query = data.query::<(&x::Window, &mut WindowData)>();
@ -151,9 +159,19 @@ impl SurfaceEvents {
conn.focus_window(*window, output);
}
drop(query);
if state.fractional_scale.is_none() {
let output_scale = output_data.get::<&OutputScaleFactor>().unwrap().get();
data.get::<&mut SurfaceScaleFactor>().unwrap().0 = output_scale;
drop(query);
update_surface_viewport(state.world.query_one(target).unwrap());
} else {
let scale = data.get::<&SurfaceScaleFactor>().unwrap();
if update_output_scale(
state.world.query_one(on_output.0).unwrap(),
OutputScaleFactor::Fractional(scale.0),
) {
state.updated_outputs.push(on_output.0);
}
}
}
cmd.insert_one(target, on_output);
@ -200,20 +218,19 @@ impl SurfaceEvents {
drop(xdg);
if let Some(pending) = pending {
let mut query = data.query::<(&mut SurfaceScaleFactor, &x::Window, &mut WindowData)>();
let mut query = data.query::<(&SurfaceScaleFactor, &x::Window, &mut WindowData)>();
let (scale_factor, window, window_data) = query.get().unwrap();
let scale_factor = scale_factor.0;
let window = *window;
let x = (pending.x as f64 * scale_factor) as i32 + window_data.output_offset.x;
let y = (pending.y as f64 * scale_factor) as i32 + window_data.output_offset.y;
let x = (pending.x as f64 * scale_factor.0) as i32 + window_data.output_offset.x;
let y = (pending.y as f64 * scale_factor.0) as i32 + window_data.output_offset.y;
let width = if pending.width > 0 {
(pending.width as f64 * scale_factor) as u16
(pending.width as f64 * scale_factor.0) as u16
} else {
window_data.attrs.dims.width
};
let height = if pending.height > 0 {
(pending.height as f64 * scale_factor) as u16
(pending.height as f64 * scale_factor.0) as u16
} else {
window_data.attrs.dims.height
};
@ -452,7 +469,7 @@ impl Event for client::wl_pointer::Event {
let surface_is_popup = matches!(role, SurfaceRole::Popup(_));
let mut do_enter = || {
debug!("pointer entering {} ({serial})", surface.id());
debug!("pointer entering {} ({serial} {})", surface.id(), scale.0);
server.enter(serial, surface, surface_x * scale.0, surface_y * scale.0);
state.connection.as_mut().unwrap().raise_to_top(*window);
if !surface_is_popup {
@ -488,6 +505,7 @@ impl Event for client::wl_pointer::Event {
cmd.run_on(&mut state.world);
}
client::wl_pointer::Event::Leave { serial, surface } => {
let _ = state.world.remove_one::<PendingEnter>(target);
if !surface.is_alive() {
return;
}
@ -720,13 +738,47 @@ impl Event for client::wl_touch::Event {
}
}
#[derive(Copy, Clone)]
pub(super) struct OnOutput(pub Entity);
struct OutputName(String);
fn get_output_name(output: Option<&OnOutput>, world: &World) -> Option<String> {
output.map(|o| world.get::<&OutputName>(o.0).unwrap().0.clone())
}
pub(super) struct OutputScaleFactor(pub i32);
#[derive(Copy, Clone, PartialEq, Debug)]
pub(super) enum OutputScaleFactor {
Output(i32),
Fractional(f64),
}
impl OutputScaleFactor {
pub(super) fn get(&self) -> f64 {
match *self {
Self::Output(o) => o as _,
Self::Fractional(f) => f,
}
}
}
#[must_use]
fn update_output_scale(
mut output_scale: hecs::QueryOne<&mut OutputScaleFactor>,
factor: OutputScaleFactor,
) -> bool {
let output_scale = output_scale.get().unwrap();
if matches!(output_scale, OutputScaleFactor::Fractional(..))
&& matches!(factor, OutputScaleFactor::Output(..))
{
return false;
}
if *output_scale != factor {
*output_scale = factor;
return true;
}
false
}
enum OutputDimensionsSource {
// The data in this variant is the values needed for the wl_output.geometry event.
@ -1012,26 +1064,15 @@ impl OutputEvent {
"{} scale: {factor}",
state.world.get::<&WlOutput>(target).unwrap().id()
);
state.world.get::<&mut OutputScaleFactor>(target).unwrap().0 = factor;
if update_output_scale(
state.world.query_one(target).unwrap(),
OutputScaleFactor::Output(factor),
) {
state.updated_outputs.push(target);
}
if state.fractional_scale.is_none() {
let mut surfaces = vec![];
for (entity, (scale, _)) in state
.world
.query_mut::<(&mut SurfaceScaleFactor, &OnOutput)>()
.with::<&WindowData>()
.into_iter()
.filter(|(_, (_, o))| o.0 == target)
{
surfaces.push(entity);
scale.0 = factor as f64;
}
for entity in surfaces {
update_surface_viewport(state.world.query_one(entity).unwrap());
}
state.world.get::<&WlOutput>(target).unwrap().scale(factor);
}
state.output_scales_updated = true;
}
Event::Name { name } => {
state

92
src/server/mod.rs
View file

@ -173,9 +173,6 @@ struct SurfaceAttach {
#[derive(PartialEq, Eq)]
struct SurfaceSerial([u32; 2]);
#[derive(Copy, Clone)]
struct SurfaceScaleFactor(f64);
#[derive(Debug)]
enum SurfaceRole {
Toplevel(Option<ToplevelData>),
@ -418,8 +415,8 @@ pub struct ServerState<C: XConnection> {
activation_state: Option<ActivationState>,
global_output_offset: GlobalOutputOffset,
global_offset_updated: bool,
output_scales_updated: bool,
new_scale: Option<i32>,
updated_outputs: Vec<Entity>,
new_scale: Option<f64>,
}
impl<C: XConnection> ServerState<C> {
@ -507,7 +504,7 @@ impl<C: XConnection> ServerState<C> {
},
},
global_offset_updated: false,
output_scales_updated: false,
updated_outputs: Vec::new(),
new_scale: None,
decoration_manager,
world: MyWorld::new(global_list),
@ -999,19 +996,42 @@ impl<C: XConnection> ServerState<C> {
self.global_offset_updated = false;
}
if self.output_scales_updated {
if !self.updated_outputs.is_empty() {
for output in self.updated_outputs.drain(..) {
let output_scale = self.world.get::<&OutputScaleFactor>(output).unwrap();
if matches!(*output_scale, OutputScaleFactor::Output(..)) {
let mut surface_query = self
.world
.query::<(&OnOutput, &mut SurfaceScaleFactor)>()
.with::<(&WindowData, &WlSurface)>();
let mut surfaces = vec![];
for (surface, (OnOutput(s_output), surface_scale)) in surface_query.iter() {
if *s_output == output {
surface_scale.0 = output_scale.get();
surfaces.push(surface);
}
}
drop(surface_query);
for surface in surfaces {
update_surface_viewport(self.world.query_one(surface).unwrap());
}
}
}
let mut mixed_scale = false;
let mut scale;
let mut outputs = self.world.query_mut::<&OutputScaleFactor>().into_iter();
let (_, output_scale) = outputs.next().unwrap();
scale = output_scale.0;
scale = output_scale.get();
for (_, output_scale) in outputs {
if output_scale.0 != scale {
if output_scale.get() != scale {
mixed_scale = true;
scale = scale.min(output_scale.0);
scale = scale.min(output_scale.get());
}
}
@ -1021,8 +1041,6 @@ impl<C: XConnection> ServerState<C> {
debug!("Using new scale {scale}");
self.new_scale = Some(scale);
self.output_scales_updated = false;
}
{
@ -1049,7 +1067,7 @@ impl<C: XConnection> ServerState<C> {
.expect("Failed flushing clientside events");
}
pub fn new_global_scale(&mut self) -> Option<i32> {
pub fn new_global_scale(&mut self) -> Option<f64> {
self.new_scale.take()
}
@ -1156,26 +1174,18 @@ impl<C: XConnection> ServerState<C> {
}
}
let initial_scale;
let role = if let Some(parent) = popup_for {
let data;
(initial_scale, data) = self.create_popup(entity, xdg_surface, parent);
let data = self.create_popup(entity, xdg_surface, parent);
SurfaceRole::Popup(Some(data))
} else {
initial_scale = 1.0;
let data = self.create_toplevel(entity, xdg_surface, fullscreen);
SurfaceRole::Toplevel(Some(data))
};
let (surface_role, scale_factor, client) = self
let (surface_role, client) = self
.world
.query_one_mut::<(
Option<&SurfaceRole>,
&mut SurfaceScaleFactor,
&client::wl_surface::WlSurface,
)>(entity)
.query_one_mut::<(Option<&SurfaceRole>, &client::wl_surface::WlSurface)>(entity)
.unwrap();
scale_factor.0 = initial_scale;
let new_role_type = std::mem::discriminant(&role);
if let Some(role) = surface_role {
@ -1294,13 +1304,13 @@ impl<C: XConnection> ServerState<C> {
}
}
fn create_popup(
&mut self,
entity: Entity,
xdg: XdgSurface,
parent: x::Window,
) -> (f64, PopupData) {
let window = self.world.get::<&WindowData>(entity).unwrap();
fn create_popup(&mut self, entity: Entity, xdg: XdgSurface, parent: x::Window) -> PopupData {
let mut query = self
.world
.query_one::<(&WindowData, &mut SurfaceScaleFactor)>(entity)
.unwrap();
let (window, scale) = query.get().unwrap();
let mut parent_query = self
.world
.query_one::<(&WindowData, &SurfaceScaleFactor, &SurfaceRole)>(self.windows[&parent])
@ -1308,6 +1318,7 @@ impl<C: XConnection> ServerState<C> {
let (parent_window, parent_scale, parent_role) = parent_query.get().unwrap();
let parent_dims = parent_window.attrs.dims;
let initial_scale = parent_scale.0;
*scale = *parent_scale;
debug!(
"creating popup ({:?}) {:?} {:?} {:?} {entity:?} (scale: {initial_scale})",
@ -1340,18 +1351,15 @@ impl<C: XConnection> ServerState<C> {
entity,
);
(
initial_scale,
PopupData {
popup,
positioner,
xdg: XdgSurfaceData {
surface: xdg,
configured: false,
pending: None,
},
PopupData {
popup,
positioner,
xdg: XdgSurfaceData {
surface: xdg,
configured: false,
pending: None,
},
)
}
}
fn close_x_window(&mut self, window: x::Window) {

4
src/server/tests.rs
View file

@ -1965,6 +1965,7 @@ fn fractional_scale_popup() {
testwl.enable_fractional_scale();
});
let comp = f.compositor();
let (_, output) = f.new_output(0, 0);
let toplevel = unsafe { Window::new(1) };
let (_, toplevel_id) = f.create_toplevel(&comp, toplevel);
@ -1978,6 +1979,7 @@ fn fractional_scale_popup() {
.expect("No fractional scale for surface");
fractional.preferred_scale(180); // 1.5 scale
f.testwl.move_surface_to_output(toplevel_id, &output);
f.run();
f.run();
@ -2038,6 +2040,7 @@ fn fractional_scale_small_popup() {
});
let comp = f.compositor();
let (_, output) = f.new_output(0, 0);
let toplevel = unsafe { Window::new(1) };
let (_, toplevel_id) = f.create_toplevel(&comp, toplevel);
let data = f.testwl.get_surface_data(toplevel_id).unwrap();
@ -2046,6 +2049,7 @@ fn fractional_scale_small_popup() {
.as_ref()
.expect("Missing fracitonal scale data");
fractional.preferred_scale(180); // 1.5 scale
f.testwl.move_surface_to_output(toplevel_id, &output);
f.run();
f.run();