gardesk/gardisplay / 7967ccf

+        // Update monitor positions and settings from profile

+

+                // 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));

+    }

+

+            // Pass mode_width/mode_height (raw resolution) to display panel so

+            // the resolution dropdown shows actual hardware modes, not scaled values.

+                state.mode_width,

+                state.mode_height,

+                    // Read per-monitor scale from CRTC transform

+                    let scale = o

+                        .crtc

+                        .map(|c| randr.get_crtc_scale(c))

+                        .unwrap_or(1.0);

+                        scale,

+                        rotation: 0, // TODO: capture actual rotation

+        // Use mode_width/mode_height (raw hardware resolution) for the RandR mode,

+        // not info.rect which holds effective (scaled) dimensions.

+                width: state.mode_width,

+                height: state.mode_height,

+        // Apply CRTCs using the same approach as xrandr:

+        // 1. Apply each CRTC (ensure_screen_size inside apply_monitor grows if needed)

+        // 2. Shrink the screen to fit effective dimensions after all CRTCs are applied

+        //

+        // When scaling down (e.g., 2x), the CRTC transform reduces the scanout size

+        // (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.

+        // 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);

+        }

+

+        // Refit window to the new screen dimensions before showing overlay

+        self.refit_window();

+

+        // Show confirmation overlay (uses current window size after refit)

+        // 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.

+                    state.mode_width,

+                    state.mode_height,

+        self.refit_window();

+                // Apply CRTCs (ensure_screen_size inside grows if needed), then shrink

+                let _ = randr.shrink_screen_to_fit();

+        self.refit_window();

+        // Apply via RandR using disable→resize→apply pattern

+            let configs: Vec<MonitorConfig> = self

+                .original_monitors

+                .iter()

+                .map(|m| MonitorConfig {

+                })

+                .collect();

+            // Apply CRTCs (ensure_screen_size inside grows if needed), then shrink

+            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();

+        self.refit_window();

+        // Build profile from current layout using raw mode dimensions

+                enabled: state.enabled,

+                width: state.mode_width,

+                height: state.mode_height,

+                refresh: state.refresh,

+                scale: state.scale,

+                rotation: state.rotation,

+                enabled: state.enabled,

+                width: state.mode_width,

+                height: state.mode_height,

+                refresh: state.refresh,

+                scale: state.scale,

+                rotation: state.rotation,

+//! DPI and UI scaling for X11.

+//! X11 doesn't have native HiDPI scaling like Wayland. Scaling is achieved by:

+//! 1. xsettingsd for GTK applications (Gdk/WindowScalingFactor)

+//! 2. Xft.dpi via X resources (affects fonts and DPI-aware apps)

+//! 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;

+/// Get the xsettingsd config file path.

+fn xsettingsd_config_path() -> PathBuf {

+    let runtime_dir =

+        std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".to_string());

+    PathBuf::from(runtime_dir).join("gardisplay-xsettingsd.conf")

+}

+/// Write the xsettingsd configuration file.

+fn write_xsettingsd_config(scale: f64) -> std::io::Result<PathBuf> {

+    let config_path = xsettingsd_config_path();

+    let scale_factor = scale.round() as u32;

+    let dpi = (BASE_DPI as f64 * scale).round() as u32;

+    // xsettingsd uses fixed-point format: value * 1024

+    let xft_dpi_fixed = dpi * 1024;

+    let unscaled_dpi_fixed = BASE_DPI * 1024;

+

+    let config = format!(

+        r#"# Generated by gardisplay

+Gdk/WindowScalingFactor {scale_factor}

+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()?;

+        return None;

+    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);

+

+    child.wait()?;

+    Ok(())

+}

+

+/// 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!("scaling applied - new apps will use scale {}", scale);

+/// Get the current DPI setting from xrdb.

+#[allow(dead_code)] // Available for supplemental DPI queries

+    let output = Command::new("xrdb").arg("-query").output().ok()?;

+#[allow(dead_code)] // Available for supplemental DPI queries

+

+    #[test]

+    fn test_xsettingsd_config_path() {

+        let path = xsettingsd_config_path();

+        assert!(path.to_string_lossy().contains("gardisplay-xsettingsd"));

+    }

+use x11rb::protocol::render;

+use x11rb::protocol::xproto::ConnectionExt as XprotoExt;

+/// 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),

+    }

+}

+

+        // Use root window geometry to get the actual current virtual screen size.

+        // GetScreenInfo returns discrete "advertised" sizes which may not reflect

+        // the current virtual size set by RRSetScreenSize.

+        let geom = self

+            .get_geometry(self.root)?

+            .reply()

+            .map_err(|e| RandrError::ConfigFailed(format!("get_geometry: {}", e)))?;

+        let current_size = (geom.width as u32, geom.height as u32);

+    /// Calculate the effective desktop dimensions after rotation and scaling.

+    /// The CRTC transform scales the output, so the framebuffer (what apps see)

+    /// is the mode resolution divided by the scale factor.

+    /// e.g., 2880x1800 at scale 2.0 → effective 1440x900 framebuffer.

+    fn effective_dimensions(width: u32, height: u32, rotation: u32, scale: f64) -> (u32, u32) {

+        let (rot_w, rot_h) = 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))

+        }

+    #[allow(dead_code)] // Available but apply_layout now uses disable→resize→apply pattern

+    /// 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

+        }

+    }

+

+    /// Accounts for CRTC transforms (scaling) when computing effective dimensions.

+                // Check if this output has a scale transform

+                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;

+        // 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

+    /// 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(())

+    }

+

+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;

+

+    /// Dialog rect (centered in window).

+    dialog_rect: Rect,

+/// 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)

+}

+

+        let (dialog_rect, keep_btn, revert_btn) = compute_layout(window_rect);

+            dialog_rect,

+        let (dialog_rect, keep_btn, revert_btn) = compute_layout(rect);

+        self.dialog_rect = dialog_rect;

+        self.keep_btn = keep_btn;

+        self.revert_btn = revert_btn;

+        renderer.fill_rounded_rect(self.dialog_rect, 12.0, theme.background)?;

+        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;

+        let title_rect = Rect::new(dx, dy + 20, DIALOG_WIDTH as u32, 30);

+        let countdown_text = format!(

+            "Reverting in {} second{}...",

+            remaining,

+            if remaining == 1 { "" } else { "s" }

+        );

+        let countdown_rect = Rect::new(dx, dy + 55, DIALOG_WIDTH as u32, 24);

+/// 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];

+

+    /// Virtual resolution entries (populated when driver has limited modes).

+    virtual_resolutions: Vec<VirtualResolution>,

+            virtual_resolutions: Vec::new(),

+                // Collect unique hardware resolutions

+                let unique_resolutions: HashSet<String> = output

+

+                // If the driver only has 1 unique resolution (e.g., appledrm on Apple Silicon),

+                // generate virtual resolutions using CRTC transform scale factors.

+                // This mimics macOS's "scaled resolutions" list.

+                if unique_resolutions.len() <= 1 {

+                    if let Some(native) = output.modes.first() {

+                        self.virtual_resolutions = VIRTUAL_SCALE_FACTORS

+                            .iter()

+                            .map(|&s| {

+                                let ew = (native.width as f64 / s).round() as u32;

+                                let eh = (native.height as f64 / s).round() as u32;

+                                VirtualResolution {

+                                    eff_width: ew,

+                                    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);

+                }

+                self.virtual_resolutions.clear();

+            // Set current resolution in dropdown.

+            if !self.virtual_resolutions.is_empty() {

+                // 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);

+            }

+    /// 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()

+    }

+

+                    // Check if this is a virtual resolution (has scale annotation like "(2x)")

+                    if let Some(vr) = self.find_virtual_resolution(res) {

+                        // Virtual resolution: use native mode + scale

+                        self.current_width = vr.native_width;

+                        self.current_height = vr.native_height;

+                        self.current_scale = vr.scale;

+                        // Sync the scale dropdown

+                        let scale_str = format!("{}x", vr.scale);

+                        self.scale_dropdown.set_selected_by_name(&scale_str);

+                        self.update_refresh_dropdown(vr.native_width, vr.native_height);

+                        config_changed = true;

+                    } else {

+                        // 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;

+                        }

+                    }

+                    // 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;

+                        // 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);

+                        }

+    /// Monitor info from X11. rect.width/height hold effective (scaled) dimensions.

+    /// Raw mode width (hardware resolution, before scaling).

+    pub mode_width: u32,

+    /// Raw mode height (hardware resolution, before scaling).

+    pub mode_height: u32,

+                let mode_width = info.rect.width;

+                let mode_height = info.rect.height;

+                    mode_width,

+                    mode_height,

+            // Store raw mode resolution

+            state.mode_width = width;

+            state.mode_height = height;

+

+            // 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;

+

+    /// 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))

+        }

+    }

+

+        // 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()

+        };

+            "xrandr --output {} --mode {}x{} --pos {}x{} --rotate {} --scale {}",

+            rotation,

+            xrandr_scale

+        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 --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"));