monolith

public

Star0

Fork 0

Watch0

221 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `c663ae15e5bc`

tarball

atagen <boss@atagen.co>2026-10-19 08:38 UTC

7 files changed+166-0

scale: tell clients the output scale and advertise wp_fractional_scale_v1

Clients rendered every surface for scale 1, which the renderer then stretched. Surfaces now get wl_surface.preferred_buffer_scale and wp_fractional_scale_v1 from the output their window, popup, layer surface or lock surface is on. The first commit of a surface sends it, and anything that moves a window or changes a scale sends it again through apply_layout. X11 windows are left at scale 1 and stretched by the renderer.

Modified file: crates/monolith/src/commit.rs+1

@@ -104,6 +104,7 @@ impl CompositorHandler for State {

104104 let _ = popup.send_configure();

105105 }

106106 self.layer_commit(surface);

107+ self.send_scale_once(surface);

107108 self.dirty.redraw = true;

108109 }

109110 }

Modified file: crates/monolith/src/globals.rs+3 additions@@ -13,6 +13,7 @@ use smithay::wayland::compositor::CompositorState;
 use smithay::wayland::cursor_shape::CursorShapeManagerState;
 use smithay::wayland::dmabuf::{DmabufFeedbackBuilder, DmabufGlobal, DmabufState};
 use smithay::wayland::foreign_toplevel_list::ForeignToplevelListState;
+use smithay::wayland::fractional_scale::FractionalScaleManagerState;
 use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
 use smithay::wayland::image_capture_source::{
     ImageCaptureSourceState, OutputCaptureSourceState, ToplevelCaptureSourceState,
@@ -59,6 +60,7 @@ pub struct Protocols {
     _output_manager: OutputManagerState,
     _cursor_shape: CursorShapeManagerState,
     _viewporter: ViewporterState,
+    _fractional_scale: FractionalScaleManagerState,
 }
 
 impl Protocols {
@@ -118,6 +120,7 @@ impl Protocols {
             _output_manager: OutputManagerState::new_with_xdg_output::<State>(dh),
             _cursor_shape: CursorShapeManagerState::new::<State>(dh),
             _viewporter: ViewporterState::new::<State>(dh),
+            _fractional_scale: FractionalScaleManagerState::new::<State>(dh),
         }
     }
 }

Modified file: crates/monolith/src/lock.rs+14 additions@@ -39,6 +39,20 @@ impl Lock {
             .map(|(_, s)| s)
     }
 
+    pub fn surfaces(&self) -> impl Iterator<Item = (&Output, &LockSurface)> {
+        self.surfaces
+            .iter()
+            .map(|(o, s)| (o, s))
+            .filter(|(_, s)| s.alive())
+    }
+
+    pub fn output_of(&self, surface: &WlSurface) -> Option<Output> {
+        self.surfaces
+            .iter()
+            .find(|(_, s)| s.wl_surface() == surface)
+            .map(|(o, _)| o.clone())
+    }
+
     /// Drops what belonged to an output that was unplugged.
     pub fn forget(&mut self, output: &Output) {
         self.surfaces.retain(|(o, _)| o != output);

Modified file: crates/monolith/src/main.rs+1

@@ -21,6 +21,7 @@ mod nested;

2121 mod pacing;

2222 mod popups;

2323 mod power;

24+mod scale;

2425 mod scene;

2526 mod seat;

2627 mod signals;

Added file: crates/monolith/src/scale.rs+144 additions@@ -0,0 +1,144 @@
+//! Tells clients how many pixels make a logical one where their surfaces are
+//! shown, through wl_surface and wp_fractional_scale. X11 windows are left
+//! alone, since Xwayland draws at scale 1 and the renderer stretches it.
+
+use crate::state::State;
+use smithay::desktop::utils::with_surfaces_surface_tree;
+use smithay::desktop::{WindowSurfaceType, find_popup_root_surface, layer_map_for_output};
+use smithay::output::{Output, Scale};
+use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::Transform;
+use smithay::wayland::compositor::{SurfaceData, send_surface_state, with_states};
+use smithay::wayland::fractional_scale::{FractionalScaleHandler, with_fractional_scale};
+
+/// Set on a surface once it was told a scale, so a commit only pays for the
+/// first one.
+struct Told;
+
+impl FractionalScaleHandler for State {
+    fn new_fractional_scale(&mut self, surface: WlSurface) {
+        self.send_scale(&surface);
+    }
+}
+
+fn apply(surface: &WlSurface, states: &SurfaceData, scale: Scale) {
+    send_surface_state(surface, states, scale.integer_scale(), Transform::Normal);
+    with_fractional_scale(states, |f| f.set_preferred_scale(scale.fractional_scale()));
+    states.data_map.insert_if_missing(|| Told);
+}
+
+impl State {
+    /// Tells a surface that has not heard yet, which every commit asks of
+    /// the surfaces it may have just created.
+    pub fn send_scale_once(&self, surface: &WlSurface) {
+        if with_states(surface, |s| s.data_map.get::<Told>().is_none()) {
+            self.send_scale(surface);
+        }
+    }
+
+    pub fn send_scale(&self, surface: &WlSurface) {
+        let xwayland = surface
+            .client()
+            .is_some_and(|c| c.get_data::<smithay::xwayland::XWaylandClientData>().is_some());
+        match self.scale_output(surface).filter(|_| !xwayland) {
+            Some(output) => {
+                let scale = output.current_scale();
+                with_states(surface, |states| apply(surface, states, scale));
+            }
+            None => with_states(surface, |states| {
+                states.data_map.insert_if_missing(|| Told);
+            }),
+        }
+    }
+
+    /// Walks every surface the compositor shows, for when a scale or a
+    /// window's output changed.
+    pub fn send_scales(&self) {
+        let layout = &self.wm.layout;
+        for (id, state) in self.wm.iter() {
+            if state.window.x11_surface().is_some() {
+                continue;
+            }
+            let output = state
+                .placed
+                .map(|(_, _, o)| o)
+                .or_else(|| layout.window(id)?.output)
+                .and_then(|o| self.backend.output(o))
+                .or_else(|| self.pointer_output());
+            if let Some(scale) = output.map(|o| o.current_scale()) {
+                state
+                    .window
+                    .with_surfaces(|surface, states| apply(surface, states, scale));
+            }
+        }
+        for output in self.wm.space.outputs() {
+            let scale = output.current_scale();
+            for l in layer_map_for_output(output).layers() {
+                l.with_surfaces(|surface, states| apply(surface, states, scale));
+            }
+        }
+        for (output, surface) in self.services.lock.surfaces() {
+            let scale = output.current_scale();
+            with_surfaces_surface_tree(surface.wl_surface(), |surface, states| {
+                apply(surface, states, scale);
+            });
+        }
+        self.send_pointer_scales();
+    }
+
+    /// The cursor image and the drag icon belong to the pointer's output.
+    pub fn send_pointer_scales(&self) {
+        let Some(scale) = self.pointer_output().map(|o| o.current_scale()) else {
+            return;
+        };
+        let cursor = match &self.input.cursor_status {
+            smithay::input::pointer::CursorImageStatus::Surface(s) => Some(s),
+            _ => None,
+        };
+        let icon = self.input.dnd_icon.as_ref().map(|i| &i.surface);
+        for surface in cursor.into_iter().chain(icon) {
+            with_surfaces_surface_tree(surface, |surface, states| apply(surface, states, scale));
+        }
+    }
+
+    pub fn pointer_output(&self) -> Option<Output> {
+        self.wm
+            .space
+            .output_under(self.input.pointer_pos)
+            .next()
+            .or_else(|| self.wm.space.outputs().next())
+            .cloned()
+    }
+
+    /// The output a surface is mainly shown on.
+    fn scale_output(&self, surface: &WlSurface) -> Option<Output> {
+        let mut root = crate::idle::root_surface(surface);
+        if let Some(popup) = self.wm.popups.find_popup(&root)
+            && let Ok(parent) = find_popup_root_surface(&popup)
+        {
+            root = parent;
+        }
+        if let Some(id) = self.window_id(&root) {
+            if self.wm.window(id)?.x11_surface().is_some() {
+                return None;
+            }
+            let o = self
+                .wm
+                .get(id)?
+                .placed
+                .map(|(_, _, o)| o)
+                .or_else(|| self.wm.layout.window(id)?.output)?;
+            return self.backend.output(o);
+        }
+        let on_layer = self.wm.space.outputs().find(|o| {
+            layer_map_for_output(o)
+                .layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)
+                .is_some()
+        });
+        on_layer
+            .cloned()
+            .or_else(|| self.services.lock.output_of(&root))
+            .or_else(|| self.pointer_output())
+    }
+}

Modified file: crates/monolith/src/seat.rs+2 additions@@ -27,6 +27,7 @@ impl SeatHandler for State {
 
     fn cursor_image(&mut self, _seat: &Seat<Self>, image: CursorImageStatus) {
         self.input.cursor_status = image;
+        self.send_pointer_scales();
         self.dirty.redraw = true;
     }
 
@@ -144,6 +145,7 @@ impl WaylandDndGrabHandler for State {
             surface,
             offset: Point::default(),
         });
+        self.send_pointer_scales();
         self.dirty.redraw = true;
         let dh = self.core.display.clone();
         match type_ {

Modified file: crates/monolith/src/state.rs+1

@@ -418,6 +418,7 @@ impl State {

418418 self.sync_focus();

419419 self.follow_focus();

420420 self.update_inhibit();

421+ self.send_scales();

421422 self.dirty.redraw = true;

422423 self.dirty.snapshot = true;

423424 }

monolith

Commit c663ae15e5bc

Commit `c663ae15e5bc`