win64 0.0.17

Hand-crafted, idiomatic Rust wrappers for Win32
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use {
  super::{
    Window,
    dpi_to_scale_factor,
  },
  crate::{
    Handle,
    ORIGIN_POINT,
    declare_handle,
  },
  dpi::PhysicalPosition,
  std::collections::VecDeque,
  windows_sys::{
    Win32::{
      Foundation::{
        LPARAM,
        POINT,
        RECT,
      },
      Graphics::Gdi::{
        EnumDisplayMonitors,
        HDC,
        HMONITOR,
        MONITOR_DEFAULTTONEAREST,
        MONITOR_DEFAULTTONULL,
        MONITOR_DEFAULTTOPRIMARY,
        MONITOR_FROM_FLAGS,
        MonitorFromPoint,
        MonitorFromWindow,
      },
      UI::{
        HiDpi::{
          GetDpiForMonitor,
          MDT_EFFECTIVE_DPI,
        },
        WindowsAndMessaging,
      },
    },
    core::BOOL,
  },
};

// Adapted from Winit
// unsafe extern "system" fn(param0: HMONITOR, param1: HDC, param2: *mut super::super::Foundation::RECT, param3: super::super::Foundation::LPARAM) -> windows_sys::core::BOOL
unsafe extern "system" fn enum_display_monitors(
  hmonitor: HMONITOR,
  _hdc: HDC,
  _place: *mut RECT,
  data: LPARAM,
) -> BOOL {
  if let Some(monitors) = unsafe { (data as *mut VecDeque<Monitor>).as_mut() } {
    monitors.push_back(unsafe { Monitor::from_ptr(hmonitor) })
  };
  true.into() // continue enumeration
}

declare_handle!(
  Monitor,
  alias = "HMONITOR",
  doc = "https://learn.microsoft.com/en-us/windows/win32/winprog/windows-data-types#hmonitor"
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MonitorDefault {
  Null,
  Primary,
  Nearest,
}

impl MonitorDefault {
  const fn to_raw(self) -> MONITOR_FROM_FLAGS {
    match self {
      MonitorDefault::Null => MONITOR_DEFAULTTONULL,
      MonitorDefault::Primary => MONITOR_DEFAULTTOPRIMARY,
      MonitorDefault::Nearest => MONITOR_DEFAULTTONEAREST,
    }
  }
}

impl Monitor {
  pub const BASE_DPI: u32 = WindowsAndMessaging::USER_DEFAULT_SCREEN_DPI;

  /// # Returns
  /// If the point is contained by a display monitor, the return value is an `Monitor` handle to that display monitor.
  /// If the point is not contained by a display monitor, the return value depends on the value of `default`.
  /// If `default` is `MonitorDefault::Null`, then the return value would be `None`, otherwise it is always `Some(Monitor)`.
  ///
  pub fn from_point(pt: PhysicalPosition<i32>, default: MonitorDefault) -> Option<Self> {
    let hmonitor = unsafe { MonitorFromPoint(POINT { x: pt.x, y: pt.y }, default.to_raw()) };
    match hmonitor.is_null() {
      true => None,
      false => Some(unsafe { Self::from_ptr(hmonitor) }),
    }
  }

  pub fn available() -> VecDeque<Self> {
    let mut monitors: VecDeque<Monitor> = VecDeque::new();
    unsafe {
      EnumDisplayMonitors(
        std::ptr::null_mut(),
        std::ptr::null(),
        Some(enum_display_monitors),
        &mut monitors as *mut _ as LPARAM,
      );
    }
    monitors
  }

  pub fn primary() -> Self {
    Self::from_point(ORIGIN_POINT, MonitorDefault::Primary).unwrap()
  }

  pub fn from_window(window: Window, default: MonitorDefault) -> Option<Self> {
    let hmonitor = unsafe { MonitorFromWindow(window.to_ptr(), default.to_raw()) };
    match hmonitor.is_null() {
      true => None,
      false => Some(unsafe { Self::from_ptr(hmonitor) }),
    }
  }

  pub fn dpi(&self) -> u32 {
    let mut dpi = [0, 0];
    unsafe { GetDpiForMonitor(self.to_ptr(), MDT_EFFECTIVE_DPI, &mut dpi[0], &mut dpi[1]) };
    dpi[0]
  }

  pub fn scale_factor(&self) -> f64 {
    dpi_to_scale_factor(self.dpi())
  }
}