`7967ccf`

fix CRTC transform scaling and improve display change UX

- Fix scaling apply flow to match xrandr: apply CRTCs first, then
shrink screen (instead of disable-all → resize → apply which broke
on appledrm)
- Fix ensure_screen_size to use root window geometry instead of
GetScreenInfo discrete sizes
- Fix confirm overlay: remove black backdrop, center dialog properly
with shared layout computation for render and hit-testing
- Refit window after display changes using actual root geometry and
X server sync, preventing zoom/cutoff artifacts
- Fix transform ordering: set pending transform before SetCrtcConfig
- Track mode_width/mode_height separately from effective dimensions
- Generate virtual resolution entries for single-mode drivers

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 7967ccf6f9b0f4679efcd4331534fe3d6e694418
Parents: 673c927
Tree: 6cea5ad

7 changed files

Status	File	+	-
M	`gardisplay/src/app.rs`	144	60
M	`gardisplay/src/dpi.rs`	126	43
M	`gardisplay/src/randr/manager.rs`	182	24
M	`gardisplay/src/ui/confirm_overlay.rs`	51	57
M	`gardisplay/src/ui/display_panel.rs`	157	36
M	`gardisplay/src/ui/monitor_view.rs`	34	3
M	`gardisplay/src/watchdog.rs`	33	5

gardisplay/src/app.rsmodified

              return;
+         }
--        // Update monitor positions from profile
++        // Update monitor positions and settings from profile
          for state in view.monitors_mut() {
              if let Some(config) = config_map.get(state.info.name.as_str()) {
                  // Sanity check: don't apply positions that are clearly wrong
                          state.info.name
                      );
+                 }
++
++                // Apply mode dimensions and scaling from profile
++                state.mode_width = config.width;
++                state.mode_height = config.height;
++                state.refresh = config.refresh;
++                state.rotation = config.rotation;
++                state.scale = config.scale;
++                state.enabled = config.enabled;
++
++                // Update visual rect to effective (scaled) dimensions
++                let (rot_w, rot_h) = match config.rotation {
++                    90 | 270 => (config.height, config.width),
++                    _ => (config.width, config.height),
++                };
++                if (config.scale - 1.0).abs() < 0.001 {
++                    state.info.rect.width = rot_w;
++                    state.info.rect.height = rot_h;
++                } else {
++                    state.info.rect.width = (rot_w as f64 / config.scale).round() as u32;
++                    state.info.rect.height = (rot_h as f64 / config.scale).round() as u32;
++                }
+             }
+         }
+         }
+     }
++    /// Refit the window to the current screen after a display change.
++    /// Uses root window geometry (which reflects the effective screen size after
++    /// transforms/scaling) rather than monitor detection (which returns raw mode sizes).
++    fn refit_window(&mut self) {
++        // Sync to ensure screen resize has been processed by the X server
++        let _ = self.conn.sync();
++
++        // Query root window geometry for actual effective screen dimensions
++        let (scr_w, scr_h) = match self.conn.inner().get_geometry(self.conn.root()) {
++            Ok(cookie) => match cookie.reply() {
++                Ok(geom) => (geom.width as u32, geom.height as u32),
++                Err(_) => return,
++            },
++            Err(_) => return,
++        };
++
++        let win_w = WINDOW_WIDTH.min(scr_w.saturating_sub(40));
++        let win_h = WINDOW_HEIGHT.min(scr_h.saturating_sub(40));
++        let x = (scr_w as i32 - win_w as i32) / 2;
++        let y = (scr_h as i32 - win_h as i32) / 2;
++
++        tracing::info!(
++            "refit_window: screen={}x{}, requesting window {}x{} at ({}, {})",
++            scr_w, scr_h, win_w, win_h, x, y
++        );
++
++        if let Err(e) = self.window.set_geometry(Rect::new(x, y, win_w, win_h)) {
++            tracing::warn!("failed to refit window: {}", e);
++            return;
++        }
++
++        // Flush and sync so the WM processes the configure request
++        let _ = self.conn.flush();
++        let _ = self.conn.sync();
++
++        // Query ACTUAL window geometry (WM may have adjusted our request)
++        let (actual_w, actual_h) = match self.conn.inner().get_geometry(self.window.id()) {
++            Ok(cookie) => match cookie.reply() {
++                Ok(geom) => (geom.width as u32, geom.height as u32),
++                Err(_) => (win_w, win_h),
++            },
++            Err(_) => (win_w, win_h),
++        };
++
++        tracing::info!(
++            "refit_window: actual window size after WM = {}x{}",
++            actual_w, actual_h
++        );
++
++        // Update renderer and layout to match actual window size
++        self.handle_resize(Size::new(actual_w, actual_h));
++    }
++
      /// Update the cursor based on monitor view state.
      fn update_cursor(&mut self) {
          let shape = self.monitor_view.cursor_shape();
                  output.map(|o| o.modes.len()).unwrap_or(0)
              );
++            // Pass mode_width/mode_height (raw resolution) to display panel so
++            // the resolution dropdown shows actual hardware modes, not scaled values.
              self.display_panel.set_selected_monitor(
                  Some(&state.info.name),
                  output,
--                state.info.rect.width,
++                state.mode_width,
--                state.info.rect.height,
++                state.mode_height,
                  state.refresh,
                  state.rotation,
                  state.scale,
          let randr = self.randr.as_ref()?;
          let outputs = randr.get_outputs().ok()?;
--        // Capture current DPI scale
--        let current_scale = dpi::get_current_scale();
--
          Some(
              outputs
                  .iter()
                  .map(|o| {
                      let mode = o.current_mode.as_ref().unwrap();
                      let pos = o.position.unwrap_or((0, 0));
++                    // Read per-monitor scale from CRTC transform
++                    let scale = o
++                        .crtc
++                        .map(|c| randr.get_crtc_scale(c))
++                        .unwrap_or(1.0);
                      MonitorConfig {
                          name: o.name.clone(),
                          enabled: true,
                          width: mode.width as u32,
                          height: mode.height as u32,
                          refresh: mode.refresh,
--                        scale: current_scale, // Capture current DPI scale
++                        scale,
--                        rotation: 0,          // TODO: capture actual rotation
++                        rotation: 0, // TODO: capture actual rotation
+                     }
                  })
                  .collect(),
          self.pre_change_config = self.capture_current_randr_state();
          // Build MonitorConfig from current view state
++        // Use mode_width/mode_height (raw hardware resolution) for the RandR mode,
++        // not info.rect which holds effective (scaled) dimensions.
          let primary_name = self.monitor_view.primary_name().map(|s| s.to_string());
          let configs: Vec<MonitorConfig> = self
              .monitor_view
                  enabled: state.enabled,
                  x: state.real_position.x,
                  y: state.real_position.y,
--                width: state.info.rect.width,
++                width: state.mode_width,
--                height: state.info.rect.height,
++                height: state.mode_height,
                  refresh: state.refresh,
                  scale: state.scale,
                  rotation: state.rotation,
              })
              .collect();
--        // IMPORTANT: Prepare the screen size BEFORE applying any configurations
++        // Apply CRTCs using the same approach as xrandr:
--        // This is essential for rotation changes which may require a larger virtual screen
++        // 1. Apply each CRTC (ensure_screen_size inside apply_monitor grows if needed)
--        if let Err(e) = randr.prepare_screen_for_configs(&configs) {
++        // 2. Shrink the screen to fit effective dimensions after all CRTCs are applied
--            tracing::error!("failed to prepare screen size: {}", e);
++        //
--            self.set_status(&format!("Failed to prepare screen: {}", e));
++        // When scaling down (e.g., 2x), the CRTC transform reduces the scanout size
--            return;
++        // (2880x1800 mode at 2x → 1440x900 scanout), so it always fits within the
--        }
++        // current screen. The screen is then shrunk to match after all CRTCs are set.
--
          let mut success_count = 0;
          let mut error_count = 0;
+             }
+         }
++        // Shrink the screen to fit the effective (post-transform) dimensions.
++        // This must happen AFTER all CRTCs are applied so the server knows the
++        // actual scanout sizes. This matches xrandr's behavior.
++        if let Err(e) = randr.shrink_screen_to_fit() {
++            tracing::error!("failed to shrink screen: {}", e);
++        }
++
          // Set primary
          if let Some(ref name) = primary_name {
              if let Err(e) = randr.set_primary(name) {
              tracing::error!("failed to flush: {}", e);
+         }
--        // Try to shrink screen to fit (non-fatal if it fails)
--        if let Err(e) = randr.shrink_screen_to_fit() {
--            tracing::debug!("shrink_screen_to_fit failed (non-fatal): {}", e);
--        }
--
          // Apply DPI scaling if any monitor has non-1.0 scale
--        // Use the primary monitor's scale, or the first enabled monitor
          let scale = configs
              .iter()
              .find(|c| c.enabled && primary_name.as_ref() == Some(&c.name))
          if let Err(e) = dpi::apply_dpi_scale(scale) {
              tracing::error!("failed to apply DPI scale: {}", e);
--            // Non-fatal - continue with the rest
+         }
          if error_count > 0 {
+             }
+         }
--        // Show confirmation overlay
++        // Refit window to the new screen dimensions before showing overlay
++        self.refit_window();
++
++        // Show confirmation overlay (uses current window size after refit)
          let size = self.window.size();
          let window_rect = Rect::new(0, 0, size.width, size.height);
          self.confirm_overlay = Some(ConfirmOverlay::new(window_rect));
          watchdog::cancel_watchdog();
          self.watchdog_child = None;
--        // Update original_monitors to current state
++        // Update original_monitors to current state.
++        // Use mode_width/mode_height (raw hardware resolution) so that revert_layout
++        // can find the correct RandR mode. info.rect holds effective (scaled) dimensions
++        // which may not correspond to an actual mode.
          let primary_name = self.monitor_view.primary_name().map(|s| s.to_string());
          self.original_monitors = self
              .monitor_view
                  rect: Rect::new(
                      state.real_position.x,
                      state.real_position.y,
--                    state.info.rect.width,
++                    state.mode_width,
--                    state.info.rect.height,
++                    state.mode_height,
                  ),
                  primary: primary_name.as_ref() == Some(&state.info.name),
                  width_mm: state.info.width_mm,
              })
              .collect();
++        self.refit_window();
          self.set_status("Display settings confirmed");
          self.monitor_view.clear_dirty();
+     }
          if let Some(ref configs) = self.pre_change_config.take() {
              if let Some(ref randr) = self.randr {
--                // IMPORTANT: Prepare screen size BEFORE reverting
++                // Apply CRTCs (ensure_screen_size inside grows if needed), then shrink
--                // The pre-change config may have different dimensions than current
--                if let Err(e) = randr.prepare_screen_for_configs(configs) {
--                    tracing::error!("failed to prepare screen for revert: {}", e);
--                    // Continue anyway - we still want to try to revert
--                }
--
                  for config in configs {
                      if let Err(e) = randr.apply_monitor(config) {
                          tracing::error!("failed to revert {}: {}", config.name, e);
+                     }
+                 }
++                let _ = randr.shrink_screen_to_fit();
                  let _ = randr.flush();
--                // Try to shrink screen to fit
--                if let Err(e) = randr.shrink_screen_to_fit() {
--                    tracing::debug!("shrink_screen_to_fit failed during revert: {}", e);
--                }
--
                  // Restore DPI scale from pre-change config
                  let scale = configs
                      .iter()
          // Reset view to original monitors
          self.monitor_view.set_monitors(self.original_monitors.clone());
++        self.refit_window();
          self.set_status("Display settings reverted");
+     }
          // Restore original monitors in view
          self.monitor_view.set_monitors(self.original_monitors.clone());
--        // Apply via RandR
++        // Apply via RandR using disable→resize→apply pattern
          if let Some(ref randr) = self.randr {
--            for m in &self.original_monitors {
++            let configs: Vec<MonitorConfig> = self
--                let config = MonitorConfig {
++                .original_monitors
++                .iter()
++                .map(|m| MonitorConfig {
                      name: m.name.clone(),
                      enabled: true,
                      x: m.rect.x,
                      refresh: 60.0,
                      scale: 1.0,
                      rotation: 0,
--                };
++                })
++                .collect();
--                if let Err(e) = randr.apply_monitor(&config) {
++            // Apply CRTCs (ensure_screen_size inside grows if needed), then shrink
--                    tracing::error!("failed to revert {}: {}", m.name, e);
++            for config in &configs {
++                if let Err(e) = randr.apply_monitor(config) {
++                    tracing::error!("failed to revert {}: {}", config.name, e);
+                 }
+             }
++            let _ = randr.shrink_screen_to_fit();
              // Restore primary
              if let Some(m) = self.original_monitors.iter().find(|m| m.primary) {
              let _ = randr.flush();
+         }
++        self.refit_window();
          self.set_status("Reverted to original layout");
+     }
      fn save_profile(&mut self) {
          let primary_name = self.monitor_view.primary_name().map(|s| s.to_string());
--        // Build profile from current layout
++        // Build profile from current layout using raw mode dimensions
          let monitors: Vec<MonitorConfig> = self
              .monitor_view
              .monitors()
              .iter()
              .map(|state| MonitorConfig {
                  name: state.info.name.clone(),
--                enabled: true,
++                enabled: state.enabled,
                  x: state.real_position.x,
                  y: state.real_position.y,
--                width: state.info.rect.width,
++                width: state.mode_width,
--                height: state.info.rect.height,
++                height: state.mode_height,
--                refresh: 60.0,
++                refresh: state.refresh,
--                scale: 1.0,
++                scale: state.scale,
--                rotation: 0,
++                rotation: state.rotation,
              })
              .collect();
              .iter()
              .map(|state| MonitorConfig {
                  name: state.info.name.clone(),
--                enabled: true,
++                enabled: state.enabled,
                  x: state.real_position.x,
                  y: state.real_position.y,
--                width: state.info.rect.width,
++                width: state.mode_width,
--                height: state.info.rect.height,
++                height: state.mode_height,
--                refresh: 60.0,
++                refresh: state.refresh,
--                scale: 1.0,
++                scale: state.scale,
--                rotation: 0,
++                rotation: state.rotation,
              })
              .collect();

gardisplay/src/dpi.rsmodified

--//! DPI scaling for X11.
++//! DPI and UI scaling for X11.
  //!
--//! X11 doesn't have native HiDPI scaling like Wayland. Instead, scaling is achieved by:
++//! X11 doesn't have native HiDPI scaling like Wayland. Scaling is achieved by:
--//! 1. Setting Xft.dpi via X resources (affects fonts and DPI-aware apps)
++//! 1. xsettingsd for GTK applications (Gdk/WindowScalingFactor)
--//! 2. Environment variables (GDK_SCALE, QT_SCALE_FACTOR) for toolkit-specific scaling
++//! 2. Xft.dpi via X resources (affects fonts and DPI-aware apps)
  //!
--//! Note: DPI changes typically require applications to be restarted to take effect.
++//! IMPORTANT: On X11, scaling changes typically require apps to be restarted
++//! (or logout/login) to fully take effect. This is a fundamental X11 limitation.
++use std::fs;
++use std::io::Write;
++use std::path::PathBuf;
  use std::process::Command;
  /// Base DPI (96 is the X11 standard).
  const BASE_DPI: u32 = 96;
--/// Apply DPI scaling via xrdb.
++/// Get the xsettingsd config file path.
--/// Scale of 1.0 = 96 DPI, scale of 2.0 = 192 DPI, etc.
++fn xsettingsd_config_path() -> PathBuf {
--pub fn apply_dpi_scale(scale: f64) -> std::io::Result<()> {
++    let runtime_dir =
--    let dpi = (BASE_DPI as f64 * scale).round() as u32;
++        std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".to_string());
++    PathBuf::from(runtime_dir).join("gardisplay-xsettingsd.conf")
++}
--    tracing::info!("setting Xft.dpi to {} (scale={})", dpi, scale);
++/// Write the xsettingsd configuration file.
++fn write_xsettingsd_config(scale: f64) -> std::io::Result<PathBuf> {
++    let config_path = xsettingsd_config_path();
--    // Build the xrdb resource string
++    let scale_factor = scale.round() as u32;
--    let resource = format!("Xft.dpi: {}\n", dpi);
++    let dpi = (BASE_DPI as f64 * scale).round() as u32;
--    // Apply via xrdb -merge
++    // xsettingsd uses fixed-point format: value * 1024
--    let output = Command::new("xrdb")
++    let xft_dpi_fixed = dpi * 1024;
--        .arg("-merge")
++    let unscaled_dpi_fixed = BASE_DPI * 1024;
--        .stdin(std::process::Stdio::piped())
++
--        .stdout(std::process::Stdio::piped())
++    let config = format!(
--        .stderr(std::process::Stdio::piped())
++        r#"# Generated by gardisplay
--        .spawn()?
++Gdk/WindowScalingFactor {scale_factor}
--        .wait_with_output()?;
++Gdk/UnscaledDPI {unscaled_dpi_fixed}
++Xft/DPI {xft_dpi_fixed}
++Xft/Antialias 1
++Xft/Hinting 1
++Xft/HintStyle "hintslight"
++Xft/RGBA "rgb"
++"#
++    );
++
++    let mut file = fs::File::create(&config_path)?;
++    file.write_all(config.as_bytes())?;
++    file.sync_all()?;
++
++    tracing::debug!("wrote xsettingsd config to {:?}", config_path);
++    Ok(config_path)
++}
++
++/// Check if xsettingsd is running and return its PID.
++fn get_xsettingsd_pid() -> Option<u32> {
++    let output = Command::new("pgrep")
++        .arg("-x")
++        .arg("xsettingsd")
++        .output()
++        .ok()?;
      if !output.status.success() {
--        let stderr = String::from_utf8_lossy(&output.stderr);
++        return None;
--        tracing::error!("xrdb failed: {}", stderr);
--        return Err(std::io::Error::new(
--            std::io::ErrorKind::Other,
--            format!("xrdb failed: {}", stderr),
--        ));
+     }
--    // Also write to stdin
++    let stdout = String::from_utf8_lossy(&output.stdout);
++    stdout.trim().parse().ok()
++}
++
++/// Start xsettingsd if not running, or send SIGHUP to reload config.
++fn start_or_reload_xsettingsd(config_path: &PathBuf) -> std::io::Result<()> {
++    if let Some(pid) = get_xsettingsd_pid() {
++        // Send SIGHUP to reload config (gentler than restart)
++        tracing::info!("sending SIGHUP to xsettingsd (PID {})", pid);
++        let _ = Command::new("kill")
++            .arg("-HUP")
++            .arg(pid.to_string())
++            .status();
++    } else {
++        // Start xsettingsd
++        tracing::info!("starting xsettingsd with config {:?}", config_path);
++        Command::new("xsettingsd")
++            .arg("-c")
++            .arg(config_path)
++            .stdin(std::process::Stdio::null())
++            .stdout(std::process::Stdio::null())
++            .stderr(std::process::Stdio::null())
++            .spawn()?;
++    }
++
++    Ok(())
++}
++
++/// Apply DPI scaling via xrdb (for legacy X11 apps).
++fn apply_xrdb_dpi(dpi: u32) -> std::io::Result<()> {
++    let resource = format!("Xft.dpi: {}\n", dpi);
++
      let mut child = Command::new("xrdb")
          .arg("-merge")
          .stdin(std::process::Stdio::piped())
          .spawn()?;
      if let Some(mut stdin) = child.stdin.take() {
--        use std::io::Write;
          stdin.write_all(resource.as_bytes())?;
+     }
--    let status = child.wait()?;
++    child.wait()?;
--    if !status.success() {
++    Ok(())
--        return Err(std::io::Error::new(
++}
--            std::io::ErrorKind::Other,
++
--            "xrdb -merge failed",
++/// Apply DPI scaling for the desktop.
--        ));
++/// This sets up both xsettingsd (for GTK apps) and xrdb (for legacy apps).
++/// Scale of 1.0 = 96 DPI, scale of 2.0 = 192 DPI, etc.
++///
++/// NOTE: Existing applications may not fully update until restarted.
++/// This is a fundamental X11 limitation.
++pub fn apply_dpi_scale(scale: f64) -> std::io::Result<()> {
++    let dpi = (BASE_DPI as f64 * scale).round() as u32;
++    let scale_factor = scale.round() as u32;
++
++    tracing::info!(
++        "applying scale {} (DPI={}, WindowScalingFactor={})",
++        scale,
++        dpi,
++        scale_factor
++    );
++
++    // 1. Write xsettingsd config and reload
++    if let Ok(config_path) = write_xsettingsd_config(scale) {
++        if let Err(e) = start_or_reload_xsettingsd(&config_path) {
++            tracing::warn!("failed to start/reload xsettingsd: {}", e);
++        }
++    }
++
++    // 2. Apply xrdb DPI for legacy apps
++    if let Err(e) = apply_xrdb_dpi(dpi) {
++        tracing::warn!("failed to set xrdb DPI: {}", e);
+     }
--    tracing::info!("DPI set to {} - apps may need restart to reflect changes", dpi);
++    tracing::info!("scaling applied - new apps will use scale {}", scale);
      Ok(())
+ }
--/// Get the current DPI setting.
++/// Get the current DPI setting from xrdb.
++#[allow(dead_code)] // Available for supplemental DPI queries
  pub fn get_current_dpi() -> Option<u32> {
--    let output = Command::new("xrdb")
++    let output = Command::new("xrdb").arg("-query").output().ok()?;
--        .arg("-query")
--        .output()
--        .ok()?;
      if !output.status.success() {
          return None;
+ }
  /// Get the current scale factor based on DPI.
++#[allow(dead_code)] // Available for supplemental DPI queries
  pub fn get_current_scale() -> f64 {
      get_current_dpi()
          .map(|dpi| dpi as f64 / BASE_DPI as f64)
      #[test]
      fn test_dpi_calculation() {
--        // scale 1.0 = 96 DPI
          assert_eq!((BASE_DPI as f64 * 1.0).round() as u32, 96);
--        // scale 1.5 = 144 DPI
          assert_eq!((BASE_DPI as f64 * 1.5).round() as u32, 144);
--        // scale 2.0 = 192 DPI
          assert_eq!((BASE_DPI as f64 * 2.0).round() as u32, 192);
+     }
++
++    #[test]
++    fn test_xsettingsd_config_path() {
++        let path = xsettingsd_config_path();
++        assert!(path.to_string_lossy().contains("gardisplay-xsettingsd"));
++    }
+ }

gardisplay/src/randr/manager.rsmodified

  use gartk_x11::Connection;
  use x11rb::connection::Connection as X11Connection;
  use x11rb::protocol::randr::{self, ConnectionExt as RandrExt};
++use x11rb::protocol::render;
++use x11rb::protocol::xproto::ConnectionExt as XprotoExt;
  use super::error::{RandrError, Result};
  use super::types::{ModeInfo, OutputInfo};
  use crate::config::MonitorConfig;
++/// Convert a floating-point value to X11 Fixed (16.16 fixed-point).
++fn float_to_fixed(value: f64) -> render::Fixed {
++    (value * 65536.0) as i32
++}
++
++/// Create an identity transform matrix (no transformation).
++fn identity_transform() -> render::Transform {
++    render::Transform {
++        matrix11: float_to_fixed(1.0),
++        matrix12: float_to_fixed(0.0),
++        matrix13: float_to_fixed(0.0),
++        matrix21: float_to_fixed(0.0),
++        matrix22: float_to_fixed(1.0),
++        matrix23: float_to_fixed(0.0),
++        matrix31: float_to_fixed(0.0),
++        matrix32: float_to_fixed(0.0),
++        matrix33: float_to_fixed(1.0),
++    }
++}
++
++/// Create a scaling transform matrix.
++/// For RandR CRTC transforms, `scale` is the UI scale factor (e.g., 2.0 = "2x bigger").
++/// The transform uses the inverse: 1/scale on the diagonal.
++fn scale_transform(scale: f64) -> render::Transform {
++    let factor = 1.0 / scale;
++    render::Transform {
++        matrix11: float_to_fixed(factor),
++        matrix12: float_to_fixed(0.0),
++        matrix13: float_to_fixed(0.0),
++        matrix21: float_to_fixed(0.0),
++        matrix22: float_to_fixed(factor),
++        matrix23: float_to_fixed(0.0),
++        matrix31: float_to_fixed(0.0),
++        matrix32: float_to_fixed(0.0),
++        matrix33: float_to_fixed(1.0),
++    }
++}
++
  /// Manager for RandR operations.
  pub struct RandrManager {
      conn: Connection,
      /// Ensure the virtual screen is large enough to contain the given bounds.
      /// This must be called before applying configurations that might exceed the current screen size.
      pub fn ensure_screen_size(&self, required_width: u32, required_height: u32) -> Result<()> {
--        let _resources = self.get_resources()?;
++        // Use root window geometry to get the actual current virtual screen size.
--
++        // GetScreenInfo returns discrete "advertised" sizes which may not reflect
--        // Get current screen info
++        // the current virtual size set by RRSetScreenSize.
--        let screen_info = self
++        let geom = self
              .conn
              .inner()
--            .randr_get_screen_info(self.root)?
++            .get_geometry(self.root)?
--            .reply()?;
++            .reply()
++            .map_err(|e| RandrError::ConfigFailed(format!("get_geometry: {}", e)))?;
--        let current_size = screen_info
++        let current_size = (geom.width as u32, geom.height as u32);
--            .sizes
--            .get(screen_info.size_id as usize)
--            .map(|s| (s.width as u32, s.height as u32))
--            .unwrap_or((0, 0));
          tracing::debug!(
              "ensure_screen_size: current={}x{}, required={}x{}",
+         }
+     }
--    /// Calculate the effective desktop dimensions after rotation.
++    /// Calculate the effective desktop dimensions after rotation and scaling.
--    /// Note: Scale is handled by the transform, not by changing mode resolution.
++    /// The CRTC transform scales the output, so the framebuffer (what apps see)
--    /// The framebuffer stays at the mode resolution; the transform scales output.
++    /// is the mode resolution divided by the scale factor.
--    fn effective_dimensions(width: u32, height: u32, rotation: u32, _scale: f64) -> (u32, u32) {
++    /// e.g., 2880x1800 at scale 2.0 → effective 1440x900 framebuffer.
--        // Scale doesn't affect framebuffer size - it's handled by the CRTC transform
++    fn effective_dimensions(width: u32, height: u32, rotation: u32, scale: f64) -> (u32, u32) {
--        // The mode resolution determines the framebuffer size
++        let (rot_w, rot_h) = Self::rotated_dimensions(width, height, rotation);
--        Self::rotated_dimensions(width, height, rotation)
++        if (scale - 1.0).abs() < 0.001 {
++            (rot_w, rot_h)
++        } else {
++            let eff_w = (rot_w as f64 / scale).round() as u32;
++            let eff_h = (rot_h as f64 / scale).round() as u32;
++            (eff_w.max(1), eff_h.max(1))
++        }
+     }
      /// Calculate the required screen size to contain all given monitor configurations.
      /// Prepare the screen for a set of monitor configurations.
      /// This should be called before applying any configurations to ensure the screen is large enough.
++    #[allow(dead_code)] // Available but apply_layout now uses disable→resize→apply pattern
      pub fn prepare_screen_for_configs(&self, configs: &[MonitorConfig]) -> Result<()> {
          let (required_width, required_height) = Self::calculate_required_screen_size(configs);
          tracing::info!(
          self.ensure_screen_size(required_width, required_height)
+     }
++    /// Read the current CRTC transform scale factor.
++    /// Returns 1.0 if no transform or identity transform.
++    pub fn get_crtc_scale(&self, crtc: randr::Crtc) -> f64 {
++        let Ok(cookie) = self.conn.inner().randr_get_crtc_transform(crtc) else {
++            return 1.0;
++        };
++        let Ok(reply) = cookie.reply() else {
++            return 1.0;
++        };
++
++        // The current transform matrix11 is 1/scale in 16.16 fixed-point
++        let matrix11 = reply.current_transform.matrix11;
++        if matrix11 <= 0 {
++            return 1.0;
++        }
++
++        let factor = matrix11 as f64 / 65536.0;
++        if (factor - 1.0).abs() < 0.001 {
++            1.0
++        } else {
++            1.0 / factor // Convert back to UI scale
++        }
++    }
++
      /// Shrink the screen to the minimum size required for the current outputs.
      /// Call this after applying all configurations to clean up excess virtual screen space.
++    /// Accounts for CRTC transforms (scaling) when computing effective dimensions.
      pub fn shrink_screen_to_fit(&self) -> Result<()> {
          let outputs = self.get_outputs()?;
                  continue;
+             }
              if let (Some(mode), Some(pos)) = (&output.current_mode, output.position) {
--                let right = pos.0.max(0) as u32 + mode.width as u32;
++                // Check if this output has a scale transform
--                let bottom = pos.1.max(0) as u32 + mode.height as u32;
++                let scale = output.crtc.map(|c| self.get_crtc_scale(c)).unwrap_or(1.0);
++                let (eff_w, eff_h) =
++                    Self::effective_dimensions(mode.width as u32, mode.height as u32, 0, scale);
++                let right = pos.0.max(0) as u32 + eff_w;
++                let bottom = pos.1.max(0) as u32 + eff_h;
                  max_x = max_x.max(right);
                  max_y = max_y.max(bottom);
+             }
              _ => randr::Rotation::ROTATE0,
          };
--        // Apply configuration
++        // Set CRTC transform BEFORE set_crtc_config.
++        // Per the RandR spec, SetCrtcTransform stores a "pending" transform.
++        // The next SetCrtcConfig call activates it. So we must set the transform first.
++        if (config.scale - 1.0).abs() > 0.001 {
++            let transform = scale_transform(config.scale);
++            let filter = if (config.scale.round() - config.scale).abs() < 0.001 {
++                b"nearest".as_slice() // Integer scale: pixel-perfect
++            } else {
++                b"bilinear".as_slice() // Fractional scale: smooth interpolation
++            };
++            self.conn
++                .inner()
++                .randr_set_crtc_transform(crtc, transform, filter, &[])?;
++            tracing::info!(
++                "set pending CRTC transform {:.2}x for {} (filter={})",
++                config.scale,
++                config.name,
++                String::from_utf8_lossy(filter)
++            );
++        } else {
++            // Reset to identity transform
++            let transform = identity_transform();
++            self.conn
++                .inner()
++                .randr_set_crtc_transform(crtc, transform, b"nearest", &[])?;
++        }
++
++        // Apply configuration — this activates the pending transform
          let result = self
              .conn
              .inner()
              )));
+         }
--        // Note: Scale is handled via DPI settings, not RandR transforms
--        // RandR transforms don't work well for HiDPI scaling on X11
--
          tracing::info!(
              "applied config for {}: {}x{} rot={} scale={} at ({}, {})",
              config.name,
          Err(RandrError::NoCrtcAvailable(name))
+     }
++    /// Set the screen to an exact size.
++    /// All CRTCs should be disabled first to avoid validation failures.
++    #[allow(dead_code)] // Available for direct screen resize
++    pub fn resize_screen(&self, width: u32, height: u32) -> Result<()> {
++        let mm_width = (width as f64 * 25.4 / 96.0) as u32;
++        let mm_height = (height as f64 * 25.4 / 96.0) as u32;
++
++        tracing::info!(
++            "resizing screen to {}x{} ({}x{}mm)",
++            width,
++            height,
++            mm_width,
++            mm_height
++        );
++
++        self.conn.inner().randr_set_screen_size(
++            self.root,
++            width as u16,
++            height as u16,
++            mm_width,
++            mm_height,
++        )?;
++        self.conn.inner().flush()?;
++        Ok(())
++    }
++
++    /// Disable all connected outputs (set CRTCs to mode 0).
++    #[allow(dead_code)] // Available for screen resize operations
++    pub fn disable_all_crtcs(&self) -> Result<()> {
++        let resources = self.get_resources()?;
++
++        for &crtc in &resources.crtcs {
++            let crtc_info = self
++                .conn
++                .inner()
++                .randr_get_crtc_info(crtc, resources.config_timestamp)?
++                .reply()?;
++
++            // Only disable active CRTCs (those with a mode set)
++            if crtc_info.mode != 0 {
++                self.conn
++                    .inner()
++                    .randr_set_crtc_config(
++                        crtc,
++                        resources.timestamp,
++                        resources.config_timestamp,
++                        0,
++                        0,
++                        0, // mode 0 = disable
++                        randr::Rotation::ROTATE0,
++                        &[],
++                    )?
++                    .reply()?;
++            }
++        }
++
++        self.conn.inner().flush()?;
++        tracing::debug!("disabled all active CRTCs");
++        Ok(())
++    }
++
      /// Flush pending X11 requests.
      pub fn flush(&self) -> Result<()> {
          self.conn.inner().flush()?;

gardisplay/src/ui/confirm_overlay.rsmodified

  /// Default timeout for confirmation (15 seconds).
  pub const CONFIRM_TIMEOUT_SECS: u64 = 15;
++const DIALOG_WIDTH: i32 = 400;
++const DIALOG_HEIGHT: i32 = 150;
++const BTN_WIDTH: i32 = 120;
++const BTN_HEIGHT: u32 = 36;
++const BTN_SPACING: i32 = 20;
++
  /// Result of handling an overlay event.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  pub enum ConfirmResult {
  /// Confirmation overlay that appears after applying display changes.
  pub struct ConfirmOverlay {
--    /// Full window rect for the overlay.
--    rect: Rect,
      /// When the confirmation started.
      start_time: Instant,
      /// Timeout duration.
      timeout: Duration,
++    /// Dialog rect (centered in window).
++    dialog_rect: Rect,
      /// Keep button rect.
      keep_btn: Rect,
      /// Revert button rect.
      revert_hovered: bool,
+ }
++/// Compute dialog and button rects centered in the given window rect.
++fn compute_layout(window_rect: Rect) -> (Rect, Rect, Rect) {
++    let dialog_x = window_rect.x + (window_rect.width as i32 - DIALOG_WIDTH) / 2;
++    let dialog_y = window_rect.y + (window_rect.height as i32 - DIALOG_HEIGHT) / 2;
++    let dialog_rect = Rect::new(dialog_x, dialog_y, DIALOG_WIDTH as u32, DIALOG_HEIGHT as u32);
++
++    let center_x = dialog_x + DIALOG_WIDTH / 2;
++    let btn_y = dialog_y + 95;
++
++    let keep_btn = Rect::new(
++        center_x - BTN_WIDTH - BTN_SPACING / 2,
++        btn_y,
++        BTN_WIDTH as u32,
++        BTN_HEIGHT,
++    );
++    let revert_btn = Rect::new(
++        center_x + BTN_SPACING / 2,
++        btn_y,
++        BTN_WIDTH as u32,
++        BTN_HEIGHT,
++    );
++
++    (dialog_rect, keep_btn, revert_btn)
++}
++
  impl ConfirmOverlay {
      /// Create a new confirmation overlay.
      pub fn new(window_rect: Rect) -> Self {
--        let btn_width = 120;
++        let (dialog_rect, keep_btn, revert_btn) = compute_layout(window_rect);
--        let btn_height = 36;
--        let btn_spacing = 20;
--        let center_x = window_rect.x + window_rect.width as i32 / 2;
--        let center_y = window_rect.y + window_rect.height as i32 / 2;
--
--        let keep_btn = Rect::new(
--            center_x - btn_width - btn_spacing / 2,
--            center_y + 30,
--            btn_width as u32,
--            btn_height,
--        );
--        let revert_btn = Rect::new(
--            center_x + btn_spacing / 2,
--            center_y + 30,
--            btn_width as u32,
--            btn_height,
--        );
          Self {
--            rect: window_rect,
              start_time: Instant::now(),
              timeout: Duration::from_secs(CONFIRM_TIMEOUT_SECS),
++            dialog_rect,
              keep_btn,
              revert_btn,
              keep_hovered: false,
      /// Update the overlay rect (e.g., on window resize).
      pub fn set_rect(&mut self, rect: Rect) {
--        self.rect = rect;
++        let (dialog_rect, keep_btn, revert_btn) = compute_layout(rect);
--        let btn_width = 120;
++        self.dialog_rect = dialog_rect;
--        let btn_height = 36;
++        self.keep_btn = keep_btn;
--        let btn_spacing = 20;
++        self.revert_btn = revert_btn;
--        let center_x = rect.x + rect.width as i32 / 2;
--        let center_y = rect.y + rect.height as i32 / 2;
--
--        self.keep_btn = Rect::new(
--            center_x - btn_width - btn_spacing / 2,
--            center_y + 30,
--            btn_width as u32,
--            btn_height,
--        );
--        self.revert_btn = Rect::new(
--            center_x + btn_spacing / 2,
--            center_y + 30,
--            btn_width as u32,
--            btn_height,
--        );
+     }
      /// Handle an input event.
+                 }
+             }
              InputEvent::Idle => {
--                // Check timeout on idle (already checked above, but log for debugging)
                  let remaining = self.remaining_secs();
                  if remaining <= 3 {
                      tracing::debug!("confirm overlay: {}s remaining", remaining);
      /// Render the overlay.
      pub fn render(&self, renderer: &Renderer, theme: &Theme) -> anyhow::Result<()> {
--        // Semi-transparent dark overlay
--        let overlay_color = Color::new(0.0, 0.0, 0.0, 0.7);
--        renderer.fill_rect(self.rect, overlay_color)?;
--
--        // Center dialog box
--        let dialog_width = 400;
--        let dialog_height = 150;
--        let dialog_x = self.rect.x + (self.rect.width as i32 - dialog_width) / 2;
--        let dialog_y = self.rect.y + (self.rect.height as i32 - dialog_height) / 2;
--        let dialog_rect = Rect::new(dialog_x, dialog_y, dialog_width as u32, dialog_height as u32);
--
          // Dialog background
--        renderer.fill_rounded_rect(dialog_rect, 12.0, theme.background)?;
++        renderer.fill_rounded_rect(self.dialog_rect, 12.0, theme.background)?;
--        renderer.stroke_rounded_rect(dialog_rect, 12.0, theme.border, 2.0)?;
++        renderer.stroke_rounded_rect(self.dialog_rect, 12.0, theme.border, 2.0)?;
++
++        let dx = self.dialog_rect.x;
++        let dy = self.dialog_rect.y;
          // Title
          let title_style = TextStyle::new()
              .color(theme.foreground)
              .align(TextAlign::Center);
--        let title_rect = Rect::new(dialog_x, dialog_y + 20, dialog_width as u32, 30);
++        let title_rect = Rect::new(dx, dy + 20, DIALOG_WIDTH as u32, 30);
          renderer.text_in_rect("Keep these display settings?", title_rect, &title_style)?;
          // Countdown
          let remaining = self.remaining_secs();
--        let countdown_text = format!("Reverting in {} second{}...", remaining, if remaining == 1 { "" } else { "s" });
++        let countdown_text = format!(
++            "Reverting in {} second{}...",
++            remaining,
++            if remaining == 1 { "" } else { "s" }
++        );
          let countdown_style = TextStyle::new()
              .font_family(&theme.font_family)
              .font_size(theme.font_size)
              .color(theme.item_description)
              .align(TextAlign::Center);
--        let countdown_rect = Rect::new(dialog_x, dialog_y + 55, dialog_width as u32, 24);
++        let countdown_rect = Rect::new(dx, dy + 55, DIALOG_WIDTH as u32, 24);
          renderer.text_in_rect(&countdown_text, countdown_rect, &countdown_style)?;
          // Keep button

gardisplay/src/ui/display_panel.rsmodified

      ConfigChanged(DisplayPanelConfig),
+ }
++/// A virtual resolution entry: native mode + scale factor.
++#[derive(Debug, Clone)]
++struct VirtualResolution {
++    /// Effective width after scaling.
++    eff_width: u32,
++    /// Effective height after scaling.
++    eff_height: u32,
++    /// Scale factor that produces this effective resolution.
++    scale: f64,
++    /// The native mode width.
++    native_width: u32,
++    /// The native mode height.
++    native_height: u32,
++}
++
++/// Common scale factors for generating virtual resolutions.
++const VIRTUAL_SCALE_FACTORS: &[f64] = &[1.0, 1.25, 1.5, 2.0];
++
  /// Display settings panel for the selected monitor.
  pub struct DisplayPanel {
      rect: Rect,
      // State
      selected_output: Option<String>,
      available_modes: Vec<ModeInfo>,
++    /// Virtual resolution entries (populated when driver has limited modes).
++    virtual_resolutions: Vec<VirtualResolution>,
      // Current values
      current_width: u32,
      current_height: u32,
              enabled_toggle,
              selected_output: None,
              available_modes: Vec::new(),
++            virtual_resolutions: Vec::new(),
              current_width: 0,
              current_height: 0,
              current_refresh: 60.0,
              if let Some(output) = output {
                  self.available_modes = output.modes.clone();
--                // Populate resolution dropdown with unique resolutions
++                // Collect unique hardware resolutions
--                let resolutions: Vec<String> = output
++                let unique_resolutions: HashSet<String> = output
                      .modes
                      .iter()
                      .map(|m| format!("{}x{}", m.width, m.height))
--                    .collect::<HashSet<_>>()
--                    .into_iter()
                      .collect();
--                let mut sorted_resolutions: Vec<String> = resolutions;
++
--                sorted_resolutions.sort_by(|a, b| {
++                // If the driver only has 1 unique resolution (e.g., appledrm on Apple Silicon),
--                    let parse_res = |s: &str| -> u64 {
++                // generate virtual resolutions using CRTC transform scale factors.
--                        let parts: Vec<&str> = s.split('x').collect();
++                // This mimics macOS's "scaled resolutions" list.
--                        if parts.len() == 2 {
++                if unique_resolutions.len() <= 1 {
--                            parts[0].parse::<u64>().unwrap_or(0)
++                    if let Some(native) = output.modes.first() {
--                                * parts[1].parse::<u64>().unwrap_or(0)
++                        self.virtual_resolutions = VIRTUAL_SCALE_FACTORS
--                        } else {
++                            .iter()
--                            0
++                            .map(|&s| {
--                        }
++                                let ew = (native.width as f64 / s).round() as u32;
--                    };
++                                let eh = (native.height as f64 / s).round() as u32;
--                    parse_res(b).cmp(&parse_res(a))
++                                VirtualResolution {
--                });
++                                    eff_width: ew,
--                self.resolution_dropdown.set_items(sorted_resolutions);
++                                    eff_height: eh,
++                                    scale: s,
++                                    native_width: native.width as u32,
++                                    native_height: native.height as u32,
++                                }
++                            })
++                            .collect();
++
++                        let mut sorted: Vec<String> = self
++                            .virtual_resolutions
++                            .iter()
++                            .map(|vr| format!("{}x{}", vr.eff_width, vr.eff_height))
++                            .collect();
++                        sorted.sort_by(|a, b| {
++                            let parse_res = |s: &str| -> u64 {
++                                // Parse "WxH" or "WxH (Sx)" — grab just the WxH part
++                                let wxh = s.split_whitespace().next().unwrap_or(s);
++                                let parts: Vec<&str> = wxh.split('x').collect();
++                                if parts.len() == 2 {
++                                    parts[0].parse::<u64>().unwrap_or(0)
++                                        * parts[1].parse::<u64>().unwrap_or(0)
++                                } else {
++                                    0
++                                }
++                            };
++                            parse_res(b).cmp(&parse_res(a))
++                        });
++                        self.resolution_dropdown.set_items(sorted);
++                    }
++                } else {
++                    // Multiple hardware modes available — use them directly
++                    self.virtual_resolutions.clear();
++                    let mut sorted_resolutions: Vec<String> =
++                        unique_resolutions.into_iter().collect();
++                    sorted_resolutions.sort_by(|a, b| {
++                        let parse_res = |s: &str| -> u64 {
++                            let parts: Vec<&str> = s.split('x').collect();
++                            if parts.len() == 2 {
++                                parts[0].parse::<u64>().unwrap_or(0)
++                                    * parts[1].parse::<u64>().unwrap_or(0)
++                            } else {
++                                0
++                            }
++                        };
++                        parse_res(b).cmp(&parse_res(a))
++                    });
++                    self.resolution_dropdown.set_items(sorted_resolutions);
++                }
                  // Populate refresh rates for current resolution
                  self.update_refresh_dropdown(width, height);
              } else {
                  // Demo mode: just show current resolution/refresh
                  self.available_modes.clear();
++                self.virtual_resolutions.clear();
                  self.resolution_dropdown.set_items(vec![format!("{}x{}", width, height)]);
                  self.refresh_dropdown.set_items(vec![format!("{:.0}Hz", refresh)]);
+             }
--            // Set current resolution
++            // Set current resolution in dropdown.
--            let current_res = format!("{}x{}", width, height);
++            if !self.virtual_resolutions.is_empty() {
--            self.resolution_dropdown.set_selected_by_name(&current_res);
++                // Find the virtual resolution matching the current scale
++                let target = self
++                    .virtual_resolutions
++                    .iter()
++                    .find(|vr| (vr.scale - scale).abs() < 0.01)
++                    .or_else(|| self.virtual_resolutions.first());
++                if let Some(vr) = target {
++                    let label = format!("{}x{}", vr.eff_width, vr.eff_height);
++                    self.resolution_dropdown.set_selected_by_name(&label);
++                }
++            } else {
++                let current_res = format!("{}x{}", width, height);
++                self.resolution_dropdown.set_selected_by_name(&current_res);
++            }
              // Set current refresh
              let current_refresh_str = format!("{:.0}Hz", refresh);
          self.refresh_dropdown.set_items(sorted_refreshes);
+     }
++    /// Find a virtual resolution entry matching a dropdown label.
++    /// Labels are either "WxH" (for scale 1x) or "WxH (Sx)" (for other scales).
++    fn find_virtual_resolution(&self, label: &str) -> Option<VirtualResolution> {
++        // Parse the effective dimensions from the label
++        let wxh = label.split_whitespace().next().unwrap_or(label);
++        let parts: Vec<&str> = wxh.split('x').collect();
++        if parts.len() != 2 {
++            return None;
++        }
++        let w: u32 = parts[0].parse().ok()?;
++        let h: u32 = parts[1].parse().ok()?;
++
++        self.virtual_resolutions
++            .iter()
++            .find(|vr| vr.eff_width == w && vr.eff_height == h)
++            .cloned()
++    }
++
      /// Get the current configuration.
      pub fn get_config(&self) -> Option<DisplayPanelConfig> {
          if self.selected_output.is_some() {
          if let Some(action) = self.resolution_dropdown.handle_event(event) {
              if let crate::ui::widgets::DropdownAction::Select(_) = action {
                  if let Some(res) = self.resolution_dropdown.selected_item() {
--                    // Parse resolution
++                    // Check if this is a virtual resolution (has scale annotation like "(2x)")
--                    let parts: Vec<&str> = res.split('x').collect();
++                    if let Some(vr) = self.find_virtual_resolution(res) {
--                    if parts.len() == 2 {
++                        // Virtual resolution: use native mode + scale
--                        if let (Ok(w), Ok(h)) = (parts[0].parse::<u32>(), parts[1].parse::<u32>()) {
++                        self.current_width = vr.native_width;
--                            self.current_width = w;
++                        self.current_height = vr.native_height;
--                            self.current_height = h;
++                        self.current_scale = vr.scale;
--                            // Update refresh rates for new resolution
++                        // Sync the scale dropdown
--                            self.update_refresh_dropdown(w, h);
++                        let scale_str = format!("{}x", vr.scale);
--                            // Select first available refresh rate
++                        self.scale_dropdown.set_selected_by_name(&scale_str);
--                            if let Some(first_refresh) = self.refresh_dropdown.selected_item() {
++                        self.update_refresh_dropdown(vr.native_width, vr.native_height);
--                                let hz_str = first_refresh.trim_end_matches("Hz");
++                        config_changed = true;
--                                if let Ok(hz) = hz_str.parse::<f64>() {
++                    } else {
--                                    self.current_refresh = hz;
++                        // Real hardware resolution: parse WxH
--                                }
++                        let parts: Vec<&str> = res.split('x').collect();
++                        if parts.len() == 2 {
++                            if let (Ok(w), Ok(h)) =
++                                (parts[0].parse::<u32>(), parts[1].parse::<u32>())
++                            {
++                                self.current_width = w;
++                                self.current_height = h;
++                                self.update_refresh_dropdown(w, h);
++                                config_changed = true;
+                             }
--                            config_changed = true;
++                        }
++                    }
++                    // Select first available refresh rate
++                    if let Some(first_refresh) = self.refresh_dropdown.selected_item() {
++                        let hz_str = first_refresh.trim_end_matches("Hz");
++                        if let Ok(hz) = hz_str.parse::<f64>() {
++                            self.current_refresh = hz;
+                         }
+                     }
+                 }
                      let scale_str = scale.trim_end_matches('x');
                      if let Ok(s) = scale_str.parse::<f64>() {
                          self.current_scale = s;
++                        // Sync virtual resolution dropdown if active
++                        if let Some(vr) = self
++                            .virtual_resolutions
++                            .iter()
++                            .find(|vr| (vr.scale - s).abs() < 0.01)
++                        {
++                            let label = format!("{}x{}", vr.eff_width, vr.eff_height);
++                            self.resolution_dropdown.set_selected_by_name(&label);
++                        }
                          config_changed = true;
+                     }
+                 }

gardisplay/src/ui/monitor_view.rsmodified

  /// Visual representation of a monitor in the layout.
  #[derive(Debug, Clone)]
  pub struct MonitorState {
--    /// Monitor info from X11.
++    /// Monitor info from X11. rect.width/height hold effective (scaled) dimensions.
      pub info: Monitor,
      /// Scaled rectangle for display (updated during drag).
      pub scaled_rect: Rect,
      pub rotation: u32,
      /// Scale factor.
      pub scale: f64,
++    /// Raw mode width (hardware resolution, before scaling).
++    pub mode_width: u32,
++    /// Raw mode height (hardware resolution, before scaling).
++    pub mode_height: u32,
+ }
  /// State for an active drag operation.
              .map(|info| {
                  let scaled_rect = self.scale_rect(&info.rect);
                  let real_position = Point::new(info.rect.x, info.rect.y);
++                let mode_width = info.rect.width;
++                let mode_height = info.rect.height;
                  MonitorState {
                      info,
                      scaled_rect,
                      refresh: 60.0, // Default, will be updated from RandR
                      rotation: 0,
                      scale: 1.0,
++                    mode_width,
++                    mode_height,
+                 }
              })
              .collect();
          enabled: bool,
      ) {
          if let Some(state) = self.monitors.iter_mut().find(|m| m.info.name == name) {
--            state.info.rect.width = width;
++            // Store raw mode resolution
--            state.info.rect.height = height;
++            state.mode_width = width;
++            state.mode_height = height;
              state.refresh = refresh;
              state.rotation = rotation;
              state.scale = scale;
              state.enabled = enabled;
++
++            // Set info.rect to effective (scaled) dimensions for visual layout
++            let (eff_w, eff_h) = Self::effective_dimensions(width, height, rotation, scale);
++            state.info.rect.width = eff_w;
++            state.info.rect.height = eff_h;
++
              self.dirty = true;
              self.recalculate_layout();
+         }
+     }
++    /// Calculate effective dimensions after rotation and scaling.
++    /// Mirrors the logic in RandrManager::effective_dimensions.
++    fn effective_dimensions(width: u32, height: u32, rotation: u32, scale: f64) -> (u32, u32) {
++        let (rot_w, rot_h) = match rotation {
++            90 | 270 => (height, width),
++            _ => (width, height),
++        };
++        if (scale - 1.0).abs() < 0.001 {
++            (rot_w, rot_h)
++        } else {
++            let eff_w = (rot_w as f64 / scale).round() as u32;
++            let eff_h = (rot_h as f64 / scale).round() as u32;
++            (eff_w.max(1), eff_h.max(1))
++        }
++    }
++
      /// Get mutable monitors.
      pub fn monitors_mut(&mut self) -> &mut [MonitorState] {
          &mut self.monitors

gardisplay/src/watchdog.rsmodified

              _ => "normal",
          };
--        // Reset any RandR transforms to identity (scale 1x1)
++        // Apply RandR transform for scaling (xrandr --scale uses inverse of UI scale)
++        let xrandr_scale = if (config.scale - 1.0).abs() > 0.001 {
++            let s = 1.0 / config.scale;
++            format!("{:.4}x{:.4}", s, s)
++        } else {
++            "1x1".to_string()
++        };
          commands.push(format!(
--            "xrandr --output {} --mode {}x{} --pos {}x{} --rotate {} --scale 1x1",
++            "xrandr --output {} --mode {}x{} --pos {}x{} --rotate {} --scale {}",
              config.name,
              config.width,
              config.height,
              config.x,
              config.y,
--            rotation
++            rotation,
++            xrandr_scale
          ));
+     }
          ];
          let commands = generate_xrandr_commands(&configs);
--        assert!(commands.contains("xrandr --output eDP-1 --mode 2880x1800 --pos 0x0 --rotate normal"));
++        assert!(commands.contains("xrandr --output eDP-1 --mode 2880x1800 --pos 0x0 --rotate normal --scale 1x1"));
--        assert!(commands.contains("xrandr --output HDMI-1 --mode 1920x1080 --pos 2880x0 --rotate left"));
++        assert!(commands.contains("xrandr --output HDMI-1 --mode 1920x1080 --pos 2880x0 --rotate left --scale 1x1"));
++    }
++
++    #[test]
++    fn test_generate_xrandr_commands_scaled() {
++        let configs = vec![MonitorConfig {
++            name: "eDP-1".to_string(),
++            enabled: true,
++            x: 0,
++            y: 0,
++            width: 2880,
++            height: 1800,
++            refresh: 60.0,
++            scale: 2.0,
++            rotation: 0,
++        }];
++
++        let commands = generate_xrandr_commands(&configs);
++        // scale 2.0 → xrandr --scale 0.5x0.5
++        assert!(commands.contains("--scale 0.5000x0.5000"));
++        // DPI should be 192 for scale 2.0
++        assert!(commands.contains("Xft.dpi: 192"));
+     }
+ }