Event Loop 2.0 API and Windows implementation (#638)

* Rename EventsLoop and associated types to EventLoop * Rename WindowEvent::Refresh to WindowEvent::Redraw * Remove second thread from win32 backend * Update run_forever to hijack thread * Replace windows Mutex with parking_lot Mutex * Implement new ControlFlow and associated events * Add StartCause::Init support, timer example * Add ability to send custom user events * Fully invert windows control flow so win32 calls into winit's callback * Add request_redraw * Rename platform to platform_impl * Rename os to platform, add Ext trait postfixes * Add platform::desktop module with EventLoopExt::run_return * Re-organize into module structure * Improve documentation * Small changes to examples * Improve docs for run and run_return * Change instances of "events_loop" to "event_loop" * Rename MonitorId to MonitorHandle * Add CHANGELOG entry * Improve WaitUntil timer precision * When SendEvent is called during event closure, buffer events * Fix resize lag when waiting in some situations * Update send test and errors that broke some examples/APIs * Improve clarity/fix typos in docs * Fix unreachable panic after setting ControlFlow to Poll during some RedrawRequested events. * Fix crash when running in release mode * Remove crossbeam dependency and make drop events work again * Remove serde implementations from ControlFlow * Fix 1.24.1 build * Fix freeze when setting decorations * Replace &EventLoop in callback with &EventLoopWindowTarget * Document and implement Debug for EventLoopWindowTarget * Fix some deadlocks that could occur when changing window state * Fix thread executor not executing closure when called from non-loop thread * Fix buffered events not getting dispatched * Fix crash with runner refcell not getting dropped * Address review feedback * Fix CHANGELOG typo * Catch panics in user callback
2019-02-05 10:30:33 -05:00 · 2019-02-05 10:30:33 -05:00 · 9602716ed2
commit 9602716ed2
parent 7be1d16263
92 changed files with 3467 additions and 1260 deletions
--- a/src/platform_impl/windows/monitor.rs
+++ b/src/platform_impl/windows/monitor.rs
@ -0,0 +1,173 @@
+use winapi::shared::minwindef::{BOOL, DWORD, LPARAM, TRUE};
+use winapi::shared::windef::{HDC, HMONITOR, HWND, LPRECT, POINT};
+use winapi::um::winnt::LONG;
+use winapi::um::winuser;
+
+use std::{mem, ptr};
+use std::collections::VecDeque;
+
+use super::{EventLoop, util};
+use dpi::{PhysicalPosition, PhysicalSize};
+use platform_impl::platform::dpi::{dpi_to_scale_factor, get_monitor_dpi};
+use platform_impl::platform::window::Window;
+
+/// Win32 implementation of the main `MonitorHandle` object.
+#[derive(Debug, Clone)]
+pub struct MonitorHandle {
+    /// Monitor handle.
+    hmonitor: HMonitor,
+    /// The system name of the monitor.
+    monitor_name: String,
+    /// True if this is the primary monitor.
+    primary: bool,
+    /// The position of the monitor in pixels on the desktop.
+    ///
+    /// A window that is positioned at these coordinates will overlap the monitor.
+    position: (i32, i32),
+    /// The current resolution in pixels on the monitor.
+    dimensions: (u32, u32),
+    /// DPI scale factor.
+    hidpi_factor: f64,
+}
+
+// Send is not implemented for HMONITOR, we have to wrap it and implement it manually.
+// For more info see:
+// https://github.com/retep998/winapi-rs/issues/360
+// https://github.com/retep998/winapi-rs/issues/396
+#[derive(Debug, Clone)]
+struct HMonitor(HMONITOR);
+
+unsafe impl Send for HMonitor {}
+
+unsafe extern "system" fn monitor_enum_proc(
+    hmonitor: HMONITOR,
+    _hdc: HDC,
+    _place: LPRECT,
+    data: LPARAM,
+) -> BOOL {
+    let monitors = data as *mut VecDeque<MonitorHandle>;
+    (*monitors).push_back(MonitorHandle::from_hmonitor(hmonitor));
+    TRUE // continue enumeration
+}
+
+pub fn get_available_monitors() -> VecDeque<MonitorHandle> {
+    let mut monitors: VecDeque<MonitorHandle> = VecDeque::new();
+    unsafe {
+        winuser::EnumDisplayMonitors(
+            ptr::null_mut(),
+            ptr::null_mut(),
+            Some(monitor_enum_proc),
+            &mut monitors as *mut _ as LPARAM,
+        );
+    }
+    monitors
+}
+
+pub fn get_primary_monitor() -> MonitorHandle {
+    const ORIGIN: POINT = POINT { x: 0, y: 0 };
+    let hmonitor = unsafe {
+        winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY)
+    };
+    MonitorHandle::from_hmonitor(hmonitor)
+}
+
+pub fn get_current_monitor(hwnd: HWND) -> MonitorHandle {
+    let hmonitor = unsafe {
+        winuser::MonitorFromWindow(hwnd, winuser::MONITOR_DEFAULTTONEAREST)
+    };
+    MonitorHandle::from_hmonitor(hmonitor)
+}
+
+impl<T> EventLoop<T> {
+    // TODO: Investigate opportunities for caching
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorHandle> {
+        get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorHandle {
+        get_primary_monitor()
+    }
+}
+
+impl Window {
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorHandle> {
+        get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorHandle {
+        get_primary_monitor()
+    }
+}
+
+pub(crate) fn get_monitor_info(hmonitor: HMONITOR) -> Result<winuser::MONITORINFOEXW, util::WinError> {
+    let mut monitor_info: winuser::MONITORINFOEXW = unsafe { mem::uninitialized() };
+    monitor_info.cbSize = mem::size_of::<winuser::MONITORINFOEXW>() as DWORD;
+    let status = unsafe {
+        winuser::GetMonitorInfoW(
+            hmonitor,
+            &mut monitor_info as *mut winuser::MONITORINFOEXW as *mut winuser::MONITORINFO,
+        )
+    };
+    if status == 0 {
+        Err(util::WinError::from_last_error())
+    } else {
+        Ok(monitor_info)
+    }
+}
+
+impl MonitorHandle {
+    pub(crate) fn from_hmonitor(hmonitor: HMONITOR) -> Self {
+        let monitor_info = get_monitor_info(hmonitor).expect("`GetMonitorInfoW` failed");
+        let place = monitor_info.rcMonitor;
+        let dimensions = (
+            (place.right - place.left) as u32,
+            (place.bottom - place.top) as u32,
+        );
+        MonitorHandle {
+            hmonitor: HMonitor(hmonitor),
+            monitor_name: util::wchar_ptr_to_string(monitor_info.szDevice.as_ptr()),
+            primary: util::has_flag(monitor_info.dwFlags, winuser::MONITORINFOF_PRIMARY),
+            position: (place.left as i32, place.top as i32),
+            dimensions,
+            hidpi_factor: dpi_to_scale_factor(get_monitor_dpi(hmonitor).unwrap_or(96)),
+        }
+    }
+
+    pub(crate) fn contains_point(&self, point: &POINT) -> bool {
+        let left = self.position.0 as LONG;
+        let right = left + self.dimensions.0 as LONG;
+        let top = self.position.1 as LONG;
+        let bottom = top + self.dimensions.1 as LONG;
+        point.x >= left && point.x <= right && point.y >= top && point.y <= bottom
+    }
+
+    #[inline]
+    pub fn get_name(&self) -> Option<String> {
+        Some(self.monitor_name.clone())
+    }
+
+    #[inline]
+    pub fn get_native_identifier(&self) -> String {
+        self.monitor_name.clone()
+    }
+
+    #[inline]
+    pub fn get_hmonitor(&self) -> HMONITOR {
+        self.hmonitor.0
+    }
+
+    #[inline]
+    pub fn get_dimensions(&self) -> PhysicalSize {
+        self.dimensions.into()
+    }
+
+    #[inline]
+    pub fn get_position(&self) -> PhysicalPosition {
+        self.position.into()
+    }
+
+    #[inline]
+    pub fn get_hidpi_factor(&self) -> f64 {
+        self.hidpi_factor
+    }
+}