monolith

public

Star0

Fork 0

Watch0

218 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `15eeea605449`

tarball

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

8 files changed+107-45

outputs: size layout areas in logical pixels

Every output was laid out in physical pixels, so a scale could not be applied anywhere. An output's area is now its transformed mode size divided by its scale, set from the config on connect and on reload for DRM and nested, and nested pointer positions are divided by the scale to match.

Modified file: crates/config/default.toml+7 additions−7 deletions@@ -39,13 +39,13 @@ urgent = "#ebcb8b"
 # Variable refresh rate on outputs that support it, off, on, or fullscreen.
 vrr = "fullscreen"
 
-# Per connector, or [output.nested] for the nested backend's window. transform,
-# position and scale follow a reload, mode needs a replug. transform is normal,
-# 90, 180, 270, flipped, flipped-90, flipped-180 or flipped-270. Outputs without
-# a position line up left to right. position is in logical pixels, the size of
-# the output divided by its scale. scale is 0.5 to 4.0 and fractional values
-# are rounded to the nearest 1/120. X11 clients are drawn at scale 1 and
-# stretched.
+# Per connector. transform, position and scale follow a reload, mode needs a
+# replug. transform is normal, 90, 180, 270, flipped, flipped-90, flipped-180 or
+# flipped-270. Outputs without a position line up left to right. position is in
+# logical pixels, the size of the output divided by its scale. scale is 0.5 to
+# 4.0 and is rounded to the nearest 1/120. X11 clients are drawn at scale 1 and
+# stretched. The nested backend's window is [output.nested], where only scale
+# applies.
 # [output.DP-1]
 # transform = "90"
 # position = [2560, 0]

Modified file: crates/monolith/src/backend.rs+19 additions−1 deletions@@ -3,9 +3,10 @@
 
 use crate::drm::Drm;
 use crate::nested::Host;
-use monolith_layout::OutputId;
+use monolith_layout::{OutputId, Rect};
 use smithay::backend::drm::DrmNode;
 use smithay::output::Output;
+use smithay::utils::{Logical, Physical, Point, Size, Transform};
 use smithay::wayland::drm_syncobj::DrmSyncobjState;
 
 pub enum Backend {
@@ -62,3 +63,20 @@ impl Backend {
         self.drm_mut()?.syncobj.as_mut()
     }
 }
+
+/// An output's rectangle in the global logical space. A mode counts physical
+/// pixels, and `scale` of them make one logical pixel.
+pub fn logical_area(
+    position: Point<i32, Logical>,
+    mode: Size<i32, Physical>,
+    transform: Transform,
+    scale: f64,
+) -> Rect {
+    let size = transform.transform_size(mode);
+    Rect::new(
+        f64::from(position.x),
+        f64::from(position.y),
+        f64::from(size.w) / scale,
+        f64::from(size.h) / scale,
+    )
+}

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

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

244244 drm.devices.reconfigure(&self.settings.config.input);

245245 }

246246 crate::drm::reconfigure_outputs(self);

247+ crate::nested::reconfigure(self);

247248 self.configure_idle();

248249 tracing::info!("config reloaded");

249250 Ok(())

Modified file: crates/monolith/src/drm.rs+20 additions−23 deletions@@ -2,7 +2,7 @@
 //! connectors, libinput for input, and one smithay DRM output per connector,
 //! each rendered when its own vblank lands.
 
-use crate::backend::Backend;
+use crate::backend::{Backend, logical_area};
 use crate::devices::Devices;
 use crate::scene::Draw;
 use crate::state::Services;
@@ -412,12 +412,13 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         .fold(0.0, f64::max);
     let position = match config.position {
         Some([x, y]) => Point::from((x, y)),
-        None => Point::from((right as i32, 0)),
+        None => Point::from((right.ceil() as i32, 0)),
     };
+    let scale = config.scale();
     output.change_current_state(
         Some(wl_mode),
         Some(transform),
-        Some(Scale::Integer(1)),
+        Some(Scale::Fractional(scale)),
         Some(position),
     );
     output.set_preferred(wl_mode);
@@ -451,20 +452,13 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
     let global = output.create_global::<State>(&core.display);
     space.map_output(&output, position);
     let (w, h) = mode.size();
-    let size = transform.transform_size(
-        smithay::utils::Size::<i32, smithay::utils::Logical>::from((i32::from(w), i32::from(h))),
-    );
-    let area = Rect::new(
-        f64::from(position.x),
-        f64::from(position.y),
-        f64::from(size.w),
-        f64::from(size.h),
-    );
+    let area = logical_area(position, wl_mode.size, transform, scale);
     let id = layout.add_output(&name, area);
     tracing::info!(
         name,
         w,
         h,
+        scale,
         refresh = mode.vrefresh(),
         ?transform,
         x = position.x,
@@ -565,30 +559,33 @@ pub fn reconfigure_outputs(state: &mut State) {
             continue;
         };
         let transform = transform(config.transform);
-        let size = transform.transform_size(mode.size);
+        let scale = config.scale();
         let position: Point<i32, Logical> = match config.position {
             Some([x, y]) => (x, y).into(),
             None => (right, 0).into(),
         };
-        right = right.max(position.x + size.w);
-        if s.output.current_transform() == transform && s.output.current_location() == position {
+        let area = logical_area(position, mode.size, transform, scale);
+        right = right.max(area.right().ceil() as i32);
+        if s.output.current_transform() == transform
+            && s.output.current_location() == position
+            && s.output.current_scale().fractional_scale() == scale
+        {
             continue;
         }
-        s.output
-            .change_current_state(None, Some(transform), None, Some(position));
-        space.map_output(&s.output, position);
-        let area = Rect::new(
-            f64::from(position.x),
-            f64::from(position.y),
-            f64::from(size.w),
-            f64::from(size.h),
+        s.output.change_current_state(
+            None,
+            Some(transform),
+            Some(Scale::Fractional(scale)),
+            Some(position),
         );
+        space.map_output(&s.output, position);
         layout.set_output_area(s.id, area);
         s.redraw = true;
         changed = true;
         tracing::info!(
             name = s.output.name(),
             ?transform,
+            scale,
             x = position.x,
             y = position.y,
             "output reconfigured"

Modified file: crates/monolith/src/lock.rs+6 additions−1 deletions@@ -94,7 +94,12 @@ fn configure(surface: &LockSurface, output: &Output) {
     let Some(mode) = output.current_mode() else {
         return;
     };
-    let size = output.current_transform().transform_size(mode.size);
+    let logical = mode
+        .size
+        .to_f64()
+        .to_logical(output.current_scale().fractional_scale())
+        .to_i32_round::<i32>();
+    let size = output.current_transform().transform_size(logical);
     let size = (size.w as u32, size.h as u32);
     surface.with_pending_state(|s| s.size = Some(size.into()));
     surface.send_configure();

Modified file: crates/monolith/src/nested/input.rs+8 additions−1 deletions@@ -51,7 +51,14 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                 surface_x,
                 surface_y,
                 ..
-            } => state.pointer_to(Point::from((surface_x, surface_y)), time),
+            } => {
+                let scale = state
+                    .backend
+                    .nested()
+                    .map_or(1.0, |h| h.output.current_scale().fractional_scale());
+                let pos = Point::from((surface_x / scale, surface_y / scale));
+                state.pointer_to(pos, time);
+            }
             wl_pointer::Event::Button {
                 button,
                 state: WEnum::Value(pressed),

Modified file: crates/monolith/src/nested/mod.rs+42 additions−10 deletions@@ -5,17 +5,17 @@
 
 mod input;
 
-use crate::backend::Backend;
+use crate::backend::{Backend, logical_area};
 use crate::state::Services;
 use crate::state::State;
 use calloop_wayland_source::WaylandSource;
-use monolith_layout::{OutputId, Rect};
+use monolith_layout::OutputId;
 use monolith_render_vk::VulkanAllocator;
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Format, Fourcc, Modifier, Slot, Swapchain};
 use smithay::backend::renderer::Bind;
 use smithay::backend::renderer::damage::OutputDamageTracker;
-use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
+use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};
 use smithay::reexports::calloop::EventLoop;
 use smithay::utils::{Logical, Size, Transform};
 use wayland_client::globals::{GlobalListContents, registry_queue_init};
@@ -122,20 +122,16 @@ pub fn init(
         size: DEFAULT_SIZE.into(),
         refresh: 60_000,
     };
+    let scale = configured_scale(state);
     output.change_current_state(
         Some(mode),
         Some(Transform::Normal),
-        None,
+        Some(Scale::Fractional(scale)),
         Some((0, 0).into()),
     );
     output.set_preferred(mode);
     state.wm.space.map_output(&output, (0, 0));
-    let area = Rect::new(
-        0.0,
-        0.0,
-        f64::from(DEFAULT_SIZE.0),
-        f64::from(DEFAULT_SIZE.1),
-    );
+    let area = logical_area((0, 0).into(), mode.size, Transform::Normal, scale);
     let output_id = state.wm.layout.add_output("nested", area);
 
     state.backend = Backend::Nested(Box::new(Host {
@@ -166,6 +162,42 @@ pub fn init(
     Ok(())
 }
 
+fn configured_scale(state: &State) -> f64 {
+    state
+        .settings
+        .config
+        .output
+        .named
+        .get("nested")
+        .map_or(1.0, |c| c.scale())
+}
+
+/// Applies a reloaded config's scale to the window's output.
+pub fn reconfigure(state: &mut State) {
+    let scale = configured_scale(state);
+    let Some(host) = state.backend.nested() else {
+        return;
+    };
+    if host.output.current_scale().fractional_scale() == scale {
+        return;
+    }
+    let (o, size) = (host.output_id, host.size);
+    host.output
+        .change_current_state(None, None, Some(Scale::Fractional(scale)), None);
+    let area = logical_area(
+        (0, 0).into(),
+        (size.w, size.h).into(),
+        Transform::Normal,
+        scale,
+    );
+    state.wm.layout.set_output_area(o, area);
+    tracing::info!(scale, "output reconfigured");
+    state.dirty.redraw = true;
+    state.reserve_layers();
+    state.reconfigure_lock();
+    state.apply_layout();
+}
+
 /// Renders a frame if something changed and the host is ready for one.
 pub fn render(state: &mut State) {
     let State {

Modified file: crates/monolith/src/state.rs+4 additions−2 deletions@@ -1,4 +1,5 @@
 use crate::anim::Animator;
+use crate::backend::logical_area;
 use crate::commands::Binds;
 use crate::focus::Focus;
 use crate::globals::Protocols;
@@ -18,7 +19,7 @@ use smithay::reexports::calloop::{EventLoop, Interest, LoopSignal, Mode, PostAct
 use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Display, DisplayHandle};
-use smithay::utils::{Clock, Logical, Monotonic, Point, SERIAL_COUNTER, Size};
+use smithay::utils::{Clock, Logical, Monotonic, Point, SERIAL_COUNTER, Size, Transform};
 use smithay::wayland::compositor::CompositorClientState;
 use smithay::wayland::shell::wlr_layer::Layer;
 use smithay::wayland::socket::ListeningSocketSource;
@@ -254,11 +255,12 @@ impl State {
     pub fn resize_output(&mut self, size: Size<i32, Logical>) {
         if let Some(host) = self.backend.nested() {
             let o = host.output_id;
-            let area = Rect::new(0.0, 0.0, f64::from(size.w), f64::from(size.h));
             let mode = smithay::output::Mode {
                 size: (size.w, size.h).into(),
                 refresh: 60_000,
             };
+            let scale = host.output.current_scale().fractional_scale();
+            let area = logical_area((0, 0).into(), mode.size, Transform::Normal, scale);
             host.output
                 .change_current_state(Some(mode), None, None, None);
             self.wm.layout.set_output_area(o, area);

monolith

Commit 15eeea605449

Commit `15eeea605449`