Expose monitor physical size

Currently only X11 and Wayland are supported.

Author: remimimimimi

src/monitor.rs

@@ -113,6 +113,14 @@ pub trait MonitorHandleProvider: AsAny + fmt::Debug + Send + Sync {
     #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
     fn position(&self) -> Option<PhysicalPosition<i32>>;
 
+    /// Returns physical size of monitor in millimeters.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11, **Wayland**, **MacOS**, **Windows**: Returns expected values.
+    /// - **Other platforms:** Always returns [`None`].
+    fn physical_size(&self) -> Option<PhysicalSize<u32>>;
+
     /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
     /// pixels and vice versa, use [`Window::scale_factor`].
     ///

src/platform_impl/apple/appkit/monitor.rs

@@ -12,7 +12,8 @@ use objc2_app_kit::NSScreen;
 use objc2_core_foundation::{CFArray, CFRetained, CFUUID};
 use objc2_core_graphics::{
     CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
-    CGDisplayMode, CGDisplayModelNumber, CGGetActiveDisplayList, CGMainDisplayID,
+    CGDisplayMode, CGDisplayModelNumber, CGDisplayScreenSize, CGGetActiveDisplayList,
+    CGMainDisplayID,
 };
 use objc2_core_video::{kCVReturnSuccess, CVDisplayLink, CVTimeFlags};
 use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
@@ -211,6 +212,18 @@ impl MonitorHandleProvider for MonitorHandle {
         Some(position.to_physical(self.scale_factor()))
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        let size_float = unsafe { CGDisplayScreenSize(self.display_id()) };
+        if size_float.width > 0.0 && size_float.height > 0.0 {
+            Some(PhysicalSize {
+                width: size_float.width.round() as _,
+                height: size_float.height.round() as _,
+            })
+        } else {
+            None
+        }
+    }
+
     fn scale_factor(&self) -> f64 {
         run_on_main(|mtm| {
             match self.ns_screen(mtm) {

src/platform_impl/apple/uikit/monitor.rs

@@ -10,7 +10,7 @@ use objc2::{available, MainThreadMarker, Message};
 use objc2_foundation::NSInteger;
 use objc2_ui_kit::{UIScreen, UIScreenMode};
 
-use crate::dpi::PhysicalPosition;
+use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::monitor::{MonitorHandleProvider, VideoMode};
 
 // Workaround for `MainThreadBound` implementing almost no traits
@@ -110,6 +110,10 @@ impl MonitorHandleProvider for MonitorHandle {
         Some((bounds.origin.x as f64, bounds.origin.y as f64).into())
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
     fn scale_factor(&self) -> f64 {
         self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
     }

src/platform_impl/linux/wayland/output.rs

@@ -5,7 +5,7 @@ use sctk::output::{Mode, OutputData};
 use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::Proxy;
 
-use crate::dpi::{LogicalPosition, PhysicalPosition};
+use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use crate::monitor::{MonitorHandleProvider as CoreMonitorHandle, VideoMode};
 
 #[derive(Clone, Debug)]
@@ -51,6 +51,13 @@ impl CoreMonitorHandle for MonitorHandle {
         }))
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        let physical_size = output_data.with_output_info(|oi| oi.physical_size);
+
+        (physical_size.0 > 0 && physical_size.1 > 0).then_some(physical_size.into())
+    }
+
     fn scale_factor(&self) -> f64 {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         output_data.scale_factor() as f64

src/platform_impl/linux/x11/monitor.rs

@@ -5,7 +5,7 @@ use x11rb::protocol::randr::{self, ConnectionExt as _};
 use x11rb::protocol::xproto;
 
 use super::{util, X11Error, XConnection};
-use crate::dpi::PhysicalPosition;
+use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::monitor::{MonitorHandleProvider, VideoMode};
 
 // Used for testing. This should always be committed as false.
@@ -41,6 +41,8 @@ pub struct MonitorHandle {
     pub(crate) position: (i32, i32),
     /// If the monitor is the primary one
     primary: bool,
+    /// The physical size of a monitor in millimeters.
+    pub(crate) physical_size: Option<PhysicalSize<u32>>,
     /// The DPI scale factor
     pub(crate) scale_factor: f64,
     /// Used to determine which windows are on this monitor
@@ -66,6 +68,10 @@ impl MonitorHandleProvider for MonitorHandle {
         Some(self.position.into())
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        self.physical_size
+    }
+
     fn scale_factor(&self) -> f64 {
         self.scale_factor
     }
@@ -125,19 +131,30 @@ impl MonitorHandle {
         crtc: &randr::GetCrtcInfoReply,
         primary: bool,
     ) -> Option<Self> {
-        let (name, scale_factor, video_modes) = xconn.get_output_info(resources, crtc)?;
+        let (name, physical_size, scale_factor, video_modes) =
+            xconn.get_output_info(resources, crtc)?;
         let dimensions = (crtc.width as u32, crtc.height as u32);
         let position = (crtc.x as i32, crtc.y as i32);
 
         let rect = util::AaRect::new(position, dimensions);
 
-        Some(MonitorHandle { id, name, scale_factor, position, primary, rect, video_modes })
+        Some(MonitorHandle {
+            id,
+            name,
+            physical_size,
+            scale_factor,
+            position,
+            primary,
+            rect,
+            video_modes,
+        })
     }
 
     pub fn dummy() -> Self {
         MonitorHandle {
             id: 0,
             name: "<dummy monitor>".into(),
+            physical_size: None,
             scale_factor: 1.0,
             position: (0, 0),
             primary: true,

src/platform_impl/linux/x11/util/randr.rs

@@ -2,6 +2,7 @@ use std::num::NonZeroU16;
 use std::str::FromStr;
 use std::{env, str};
 
+use dpi::PhysicalSize;
 use tracing::warn;
 use x11rb::protocol::randr::{self, ConnectionExt as _};
 
@@ -10,6 +11,8 @@ use crate::dpi::validate_scale_factor;
 use crate::monitor::VideoMode;
 use crate::platform_impl::platform::x11::{monitor, VideoModeHandle};
 
+pub type OutputInfo = (String, Option<PhysicalSize<u32>>, f64, Vec<VideoModeHandle>);
+
 /// Represents values of `WINIT_HIDPI_FACTOR`.
 pub enum EnvVarDPI {
     Randr,
@@ -59,7 +62,7 @@ impl XConnection {
         &self,
         resources: &monitor::ScreenResources,
         crtc: &randr::GetCrtcInfoReply,
-    ) -> Option<(String, f64, Vec<VideoModeHandle>)> {
+    ) -> Option<OutputInfo> {
         let output_info = match self
             .xcb_connection()
             .randr_get_output_info(crtc.outputs[0], x11rb::CURRENT_TIME)
@@ -127,6 +130,9 @@ impl XConnection {
             },
         );
 
+        let physical_size = (output_info.mm_width > 0 && output_info.mm_height > 0)
+            .then_some(PhysicalSize { width: output_info.mm_width, height: output_info.mm_height });
+
         let scale_factor = match dpi_env {
             EnvVarDPI::Randr => calc_dpi_factor(
                 (crtc.width.into(), crtc.height.into()),
@@ -153,7 +159,7 @@ impl XConnection {
             },
         };
 
-        Some((name, scale_factor, modes))
+        Some((name, physical_size, scale_factor, modes))
     }
 
     pub fn set_crtc_config(

src/platform_impl/web/monitor.rs

@@ -128,6 +128,10 @@ impl MonitorHandleProvider for MonitorHandle {
         self.id.unwrap_or_default()
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
     fn scale_factor(&self) -> f64 {
         self.inner.queue(|inner| inner.scale_factor())
     }

src/platform_impl/windows/monitor.rs

@@ -5,10 +5,11 @@ use std::{io, iter, mem, ptr};
 
 use windows_sys::Win32::Foundation::{BOOL, HWND, LPARAM, POINT, RECT};
 use windows_sys::Win32::Graphics::Gdi::{
-    EnumDisplayMonitors, EnumDisplaySettingsExW, GetMonitorInfoW, MonitorFromPoint,
-    MonitorFromWindow, DEVMODEW, DM_BITSPERPEL, DM_DISPLAYFREQUENCY, DM_PELSHEIGHT, DM_PELSWIDTH,
-    ENUM_CURRENT_SETTINGS, HDC, HMONITOR, MONITORINFO, MONITORINFOEXW, MONITOR_DEFAULTTONEAREST,
-    MONITOR_DEFAULTTOPRIMARY,
+    CreateDCW, DeleteDC, EnumDisplayMonitors, EnumDisplaySettingsExW, GetDeviceCaps,
+    GetMonitorInfoW, MonitorFromPoint, MonitorFromWindow, DEVMODEW, DM_BITSPERPEL,
+    DM_DISPLAYFREQUENCY, DM_PELSHEIGHT, DM_PELSWIDTH, ENUM_CURRENT_SETTINGS, HDC, HMONITOR,
+    HORZSIZE, MONITORINFO, MONITORINFOEXW, MONITOR_DEFAULTTONEAREST, MONITOR_DEFAULTTOPRIMARY,
+    VERTSIZE,
 };
 
 use super::util::decode_wide;
@@ -185,6 +186,32 @@ impl MonitorHandleProvider for MonitorHandle {
             .ok()
     }
 
+    fn physical_size(&self) -> Option<PhysicalSize<u32>> {
+        let monitor_info_ex_w = get_monitor_info(self.0).ok()?;
+
+        let hdc = unsafe {
+            CreateDCW(
+                monitor_info_ex_w.szDevice.as_ptr(),
+                monitor_info_ex_w.szDevice.as_ptr(),
+                std::ptr::null(),
+                std::ptr::null(),
+            )
+        };
+
+        let width: u32 =
+            unsafe { GetDeviceCaps(hdc, HORZSIZE.try_into().ok()?) }.try_into().ok()?;
+        let height: u32 =
+            unsafe { GetDeviceCaps(hdc, VERTSIZE.try_into().ok()?) }.try_into().ok()?;
+
+        unsafe {
+            if DeleteDC(hdc) == 0 {
+                tracing::error!("DeleteDC {:?} failed", hdc)
+            }
+        }
+
+        (width > 0 && height > 0).then_some(PhysicalSize { width, height })
+    }
+
     fn scale_factor(&self) -> f64 {
         dpi_to_scale_factor(get_monitor_dpi(self.0).unwrap_or(96))
     }