Windows: Fix fullscreen deadlock + release 0.17.1 (#622)

* Windows: Fix fullscreen deadlock

* Release winit 0.17.1

.gitignore

@@ -1,5 +1,6 @@
 Cargo.lock
 target/
 rls/
+.vscode/
 *~
 #*#

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Unreleased
 
+# Version 0.17.1 (2018-08-05)
+
+- On X11, prevent a compilation failure in release mode for versions of Rust greater than or equal to 1.30.
+- Fixed deadlock that broke fullscreen mode on Windows.
+
+# Version 0.17.0 (2018-08-02)
+
+- Cocoa and core-graphics updates.
+- Fixed thread-safety issues in several `Window` functions on Windows.
+- On MacOS, the key state for modifiers key events is now properly set.
+- On iOS, the view is now set correctly. This makes it possible to render things (instead of being stuck on a black screen), and touch events work again.
+- Added NetBSD support.
+- **Breaking:** On iOS, `UIView` is now the default root view. `WindowBuilderExt::with_root_view_class` can be used to set the root view objective-c class to `GLKView` (OpenGLES) or `MTKView` (Metal/MoltenVK).
+- On iOS, the `UIApplication` is not started until `Window::new` is called.
+- Fixed thread unsafety with cursor hiding on macOS.
+- On iOS, fixed the size of the `JmpBuf` type used for `setjmp`/`longjmp` calls. Previously this was a buffer overflow on most architectures.
+- On Windows, use cached window DPI instead of repeatedly querying the system. This fixes sporadic crashes on Windows 7.
+
+# Version 0.16.2 (2018-07-07)
+
+- On Windows, non-resizable windows now have the maximization button disabled. This is consistent with behavior on macOS and popular X11 WMs.
+- Corrected incorrect `unreachable!` usage when guessing the DPI factor with no detected monitors.
+
+# Version 0.16.1 (2018-07-02)
+
+- Added logging through `log`. Logging will become more extensive over time.
+- On X11 and Windows, the window's DPI factor is guessed before creating the window. This *greatly* cuts back on unsightly auto-resizing that would occur immediately after window creation.
+- Fixed X11 backend compilation for environments where `c_char` is unsigned.
+
 # Version 0.16.0 (2018-06-25)
 
 - Windows additionally has `WindowBuilderExt::with_no_redirection_bitmap`.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.16.0"
+version = "0.17.1"
 authors = ["The winit contributors, Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
@@ -19,19 +19,20 @@ icon_loading = ["image"]
 [dependencies]
 lazy_static = "1"
 libc = "0.2"
+log = "0.4"
 image = { version = "0.19", optional = true }
 
 [target.'cfg(target_os = "android")'.dependencies.android_glue]
 version = "0.2"
 
 [target.'cfg(target_os = "ios")'.dependencies]
-objc = "0.2"
+objc = "0.2.3"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-objc = "0.2"
-cocoa = "0.15"
+objc = "0.2.3"
+cocoa = "0.17"
 core-foundation = "0.6"
-core-graphics = "0.14"
+core-graphics = "0.16"
 
 [target.'cfg(target_os = "windows")'.dependencies.winapi]
 version = "0.3.5"
@@ -52,9 +53,9 @@ features = [
     "winuser",
 ]
 
-[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
-wayland-client = { version = "0.20.6", features = [ "dlopen", "egl", "cursor"] }
-smithay-client-toolkit = "0.2.2"
-x11-dl = "2.17.5"
-parking_lot = "0.5"
+[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
+wayland-client = { version = "0.20.10", features = [ "dlopen", "egl", "cursor"] }
+smithay-client-toolkit = "0.2.6"
+x11-dl = "2.18.3"
+parking_lot = "0.6"
 percent-encoding = "1.0"

README.md

@@ -9,7 +9,7 @@
 
 ```toml
 [dependencies]
-winit = "0.16"
+winit = "0.17"
 ```
 
 ## [Documentation](https://docs.rs/winit)

src/dpi.rs

@@ -19,19 +19,29 @@
 //! small.
 //!
 //! That's a description of what happens when the button is 100x100 *physical* pixels. Instead, let's try using 100x100
-//! *logical* pixels. To map logical pixels to physical pixels, we simply multiply by the DPI factor. On a "typical"
-//! desktop display, the DPI factor will be 1.0, so 100x100 logical pixels equates to 100x100 physical pixels. However,
-//! a 1440p display may have a DPI factor of 1.25, so the button is rendered as 125x125 physical pixels. Ideally, the
-//! button now has approximately the same perceived size across varying displays.
+//! *logical* pixels. To map logical pixels to physical pixels, we simply multiply by the DPI (dots per inch) factor.
+//! On a "typical" desktop display, the DPI factor will be 1.0, so 100x100 logical pixels equates to 100x100 physical
+//! pixels. However, a 1440p display may have a DPI factor of 1.25, so the button is rendered as 125x125 physical pixels.
+//! Ideally, the button now has approximately the same perceived size across varying displays.
 //!
 //! Failure to account for the DPI factor can create a badly degraded user experience. Most notably, it can make users
 //! feel like they have bad eyesight, which will potentially cause them to think about growing elderly, resulting in
 //! them entering an existential panic. Once users enter that state, they will no longer be focused on your application.
 //!
-//! There are two ways to get the DPI factor: either by calling
-//! [`MonitorId::get_hidpi_factor`](../struct.MonitorId.html#method.get_hidpi_factor), or
-//! [`Window::get_hidpi_factor`](../struct.Window.html#method.get_hidpi_factor). You'll almost always use the latter,
-//! which is basically equivalent to `window.get_current_monitor().get_hidpi_factor()` anyway.
+//! There are two ways to get the DPI factor:
+//! - You can track the `WindowEvent::HiDpiFactorChanged` event of your windows. This event is sent any
+//!   time the DPI factor changes, be it because the window moved to another monitor, or because the
+//!   user changed the configuration of their screen.
+//! - You can also retrieve the DPI factor of a monitor by calling
+//!   [`MonitorId::get_hidpi_factor`](../struct.MonitorId.html#method.get_hidpi_factor), or the
+//!   current DPI factor applied to a window by calling
+//!   [`Window::get_hidpi_factor`](../struct.Window.html#method.get_hidpi_factor), which is roughly equivalent
+//!   to `window.get_current_monitor().get_hidpi_factor()`.
+//!
+//! Depending on the platform, the window's actual DPI factor may only be known after
+//! the event loop has started and your window has been drawn once. To properly handle these cases,
+//! the most robust way is to monitor the `WindowEvent::HiDpiFactorChanged` event and dynamically
+//! adapt your drawing logic to follow the DPI factor.
 //!
 //! Here's an overview of what sort of DPI factors you can expect, and where they come from:
 //! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the display settings.

src/lib.rs

@@ -25,11 +25,11 @@
 //! Once a window has been created, it will *generate events*. For example whenever the user moves
 //! the window, resizes the window, moves the mouse, etc. an event is generated.
 //!
-//! The events generated by a window can be retreived from the `EventsLoop` the window was created
+//! The events generated by a window can be retrieved from the `EventsLoop` the window was created
 //! with.
 //!
 //! There are two ways to do so. The first is to call `events_loop.poll_events(...)`, which will
-//! retreive all the events pending on the windows and immediately return after no new event is
+//! retrieve all the events pending on the windows and immediately return after no new event is
 //! available. You usually want to use this method in application that render continuously on the
 //! screen, such as video games.
 //!
@@ -80,7 +80,7 @@
 //! # Drawing on the window
 //!
 //! Winit doesn't provide any function that allows drawing on a window. However it allows you to
-//! retreive the raw handle of the window (see the `os` module for that), which in turn allows you
+//! retrieve the raw handle of the window (see the `os` module for that), which in turn allows you
 //! to create an OpenGL/Vulkan/DirectX/Metal/etc. context that will draw on the window.
 //!
 
@@ -88,6 +88,8 @@
 #[macro_use]
 extern crate lazy_static;
 extern crate libc;
+#[macro_use]
+extern crate log;
 #[cfg(feature = "icon_loading")]
 extern crate image;
 
@@ -102,13 +104,13 @@ extern crate cocoa;
 extern crate core_foundation;
 #[cfg(target_os = "macos")]
 extern crate core_graphics;
-#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 extern crate x11_dl;
-#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 extern crate parking_lot;
-#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 extern crate percent_encoding;
-#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "openbsd"))]
+#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 extern crate smithay_client_toolkit as sctk;
 
 pub(crate) use dpi::*; // TODO: Actually change the imports throughout the codebase.
@@ -164,7 +166,7 @@ pub struct WindowId(platform::WindowId);
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(platform::DeviceId);
 
-/// Provides a way to retreive events from the system and from the windows that were registered to
+/// Provides a way to retrieve events from the system and from the windows that were registered to
 /// the events loop.
 ///
 /// An `EventsLoop` can be seen more or less as a "context". Calling `EventsLoop::new()`

src/os/ios.rs

@@ -2,7 +2,7 @@
 
 use std::os::raw::c_void;
 
-use {MonitorId, Window};
+use {MonitorId, Window, WindowBuilder};
 
 /// Additional methods on `Window` that are specific to iOS.
 pub trait WindowExt {
@@ -29,6 +29,22 @@ impl WindowExt for Window {
     }
 }
 
+/// Additional methods on `WindowBuilder` that are specific to iOS.
+pub trait WindowBuilderExt {
+    /// Sets the root view class used by the `Window`, otherwise a barebones `UIView` is provided.
+    ///
+    /// The class will be initialized by calling `[root_view initWithFrame:CGRect]`
+    fn with_root_view_class(self, root_view_class: *const c_void) -> WindowBuilder;
+}
+
+impl WindowBuilderExt for WindowBuilder {
+    #[inline]
+    fn with_root_view_class(mut self, root_view_class: *const c_void) -> WindowBuilder {
+        self.platform_specific.root_view_class = unsafe { &*(root_view_class as *const _) };
+        self
+    }
+}
+
 /// Additional methods on `MonitorId` that are specific to iOS.
 pub trait MonitorIdExt {
     /// Returns a pointer to the `UIScreen` that is used by this monitor.

src/os/unix.rs

@@ -1,4 +1,4 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 
 use std::os::raw;
 use std::ptr;

src/platform/ios/ffi.rs

@@ -1,10 +1,9 @@
 #![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 
 use std::ffi::CString;
-use std::mem;
 use std::os::raw::*;
 
-use objc::runtime::{Class, Object};
+use objc::runtime::Object;
 
 pub type id = *mut Object;
 pub const nil: id = 0 as id;
@@ -15,19 +14,11 @@ pub type Boolean = u32;
 
 pub const kCFRunLoopRunHandledSource: i32 = 4;
 
-pub const UIViewAutoresizingFlexibleWidth: NSUInteger = 1 << 1;
-pub const UIViewAutoresizingFlexibleHeight: NSUInteger = 1 << 4;
-
 #[cfg(target_pointer_width = "32")]
 pub type CGFloat = f32;
 #[cfg(target_pointer_width = "64")]
 pub type CGFloat = f64;
 
-#[cfg(target_pointer_width = "32")]
-pub type NSUInteger = u32;
-#[cfg(target_pointer_width = "64")]
-pub type NSUInteger = u64;
-
 #[repr(C)]
 #[derive(Debug, Clone)]
 pub struct CGPoint {
@@ -73,12 +64,24 @@ extern {
 
 extern {
     pub fn setjmp(env: *mut c_void) -> c_int;
-    pub fn longjmp(env: *mut c_void, val: c_int);
+    pub fn longjmp(env: *mut c_void, val: c_int) -> !;
 }
 
+// values taken from "setjmp.h" header in xcode iPhoneOS/iPhoneSimulator SDK
+#[cfg(any(target_arch = "x86_64"))]
+pub const JBLEN: usize = (9 * 2) + 3 + 16;
+#[cfg(any(target_arch = "x86"))]
+pub const JBLEN: usize = 18;
+#[cfg(target_arch = "arm")]
+pub const JBLEN: usize = 10 + 16 + 2;
+#[cfg(target_arch = "aarch64")]
+pub const JBLEN: usize = (14 + 8 + 2) * 2;
+
+pub type JmpBuf = [c_int; JBLEN];
+
 pub trait NSString: Sized {
     unsafe fn alloc(_: Self) -> id {
-        msg_send![class("NSString"), alloc]
+        msg_send![class!(NSString), alloc]
     }
 
     unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id;
@@ -105,10 +108,3 @@ impl NSString for id {
         msg_send![self, UTF8String]
     }
 }
-
-#[inline]
-pub fn class(name: &str) -> *mut Class {
-    unsafe {
-        mem::transmute(Class::get(name))
-    }
-}

src/platform/ios/mod.rs

@@ -61,8 +61,10 @@
 #![cfg(target_os = "ios")]
 
 use std::{fmt, mem, ptr};
+use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::os::raw::*;
+use std::sync::Arc;
 
 use objc::declare::ClassDecl;
 use objc::runtime::{BOOL, Class, Object, Sel, YES};
@@ -90,6 +92,8 @@ use self::ffi::{
     CGPoint,
     CGRect,
     id,
+    JBLEN,
+    JmpBuf,
     kCFRunLoopDefaultMode,
     kCFRunLoopRunHandledSource,
     longjmp,
@@ -97,14 +101,13 @@ use self::ffi::{
     NSString,
     setjmp,
     UIApplicationMain,
-    UIViewAutoresizingFlexibleWidth,
-    UIViewAutoresizingFlexibleHeight,
  };
 
-static mut JMPBUF: [c_int; 27] = [0; 27];
+static mut JMPBUF: Option<Box<JmpBuf>> = None;
 
 pub struct Window {
-    delegate_state: *mut DelegateState,
+    _events_queue: Arc<RefCell<VecDeque<Event>>>,
+    delegate_state: Box<DelegateState>,
 }
 
 unsafe impl Send for Window {}
@@ -112,7 +115,6 @@ unsafe impl Sync for Window {}
 
 #[derive(Debug)]
 struct DelegateState {
-    events_queue: VecDeque<Event>,
     window: id,
     controller: id,
     view: id,
@@ -123,7 +125,6 @@ struct DelegateState {
 impl DelegateState {
     fn new(window: id, controller: id, view: id, size: LogicalSize, scale: f64) -> DelegateState {
         DelegateState {
-            events_queue: VecDeque::new(),
             window,
             controller,
             view,
@@ -170,7 +171,7 @@ impl fmt::Debug for MonitorId {
 impl MonitorId {
     #[inline]
     pub fn get_uiscreen(&self) -> id {
-        let class = Class::get("UIScreen").expect("Failed to get class `UIScreen`");
+        let class = class!(UIScreen);
         unsafe { msg_send![class, mainScreen] }
     }
 
@@ -199,7 +200,7 @@ impl MonitorId {
 }
 
 pub struct EventsLoop {
-    delegate_state: *mut DelegateState,
+    events_queue: Arc<RefCell<VecDeque<Event>>>,
 }
 
 #[derive(Clone)]
@@ -208,21 +209,11 @@ pub struct EventsLoopProxy;
 impl EventsLoop {
     pub fn new() -> EventsLoop {
         unsafe {
-            if setjmp(mem::transmute(&mut JMPBUF)) != 0 {
-                let app_class = Class::get("UIApplication").expect("Failed to get class `UIApplication`");
-                let app: id = msg_send![app_class, sharedApplication];
-                let delegate: id = msg_send![app, delegate];
-                let state: *mut c_void = *(&*delegate).get_ivar("winitState");
-                let delegate_state = state as *mut DelegateState;
-                return EventsLoop { delegate_state };
+            if !msg_send![class!(NSThread), isMainThread] {
+                panic!("`EventsLoop` can only be created on the main thread on iOS");
             }
         }
-
-        create_view_class();
-        create_delegate_class();
-        start_app();
-
-        panic!("Couldn't create `UIApplication`!")
+        EventsLoop { events_queue: Default::default() }
     }
 
     #[inline]
@@ -240,29 +231,30 @@ impl EventsLoop {
     pub fn poll_events<F>(&mut self, mut callback: F)
         where F: FnMut(::Event)
     {
+        if let Some(event) = self.events_queue.borrow_mut().pop_front() {
+            callback(event);
+            return;
+        }
+
         unsafe {
-            let state = &mut *self.delegate_state;
-
-            if let Some(event) = state.events_queue.pop_front() {
-                callback(event);
-                return;
-            }
-
             // jump hack, so we won't quit on willTerminate event before processing it
-            if setjmp(mem::transmute(&mut JMPBUF)) != 0 {
-                if let Some(event) = state.events_queue.pop_front() {
+            assert!(JMPBUF.is_some(), "`EventsLoop::poll_events` must be called after window creation on iOS");
+            if setjmp(mem::transmute_copy(&mut JMPBUF)) != 0 {
+                if let Some(event) = self.events_queue.borrow_mut().pop_front() {
                     callback(event);
                     return;
                 }
             }
+        }
 
+        unsafe {
             // run runloop
             let seconds: CFTimeInterval = 0.000002;
             while CFRunLoopRunInMode(kCFRunLoopDefaultMode, seconds, 1) == kCFRunLoopRunHandledSource {}
+        }
 
-            if let Some(event) = state.events_queue.pop_front() {
-                callback(event)
-            }
+        if let Some(event) = self.events_queue.borrow_mut().pop_front() {
+            callback(event)
         }
     }
 
@@ -301,8 +293,18 @@ pub struct WindowId;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
-#[derive(Clone, Default)]
-pub struct PlatformSpecificWindowBuilderAttributes;
+#[derive(Clone)]
+pub struct PlatformSpecificWindowBuilderAttributes {
+    pub root_view_class: &'static Class,
+}
+
+impl Default for PlatformSpecificWindowBuilderAttributes {
+    fn default() -> Self {
+        PlatformSpecificWindowBuilderAttributes {
+            root_view_class: class!(UIView),
+        }
+    }
+}
 
 // TODO: AFAIK transparency is enabled by default on iOS,
 // so to be consistent with other platforms we have to change that.
@@ -310,19 +312,60 @@ impl Window {
     pub fn new(
         ev: &EventsLoop,
         _attributes: WindowAttributes,
-        _pl_alltributes: PlatformSpecificWindowBuilderAttributes,
+        pl_attributes: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Window, CreationError> {
-        Ok(Window { delegate_state: ev.delegate_state })
+        unsafe {
+            debug_assert!(mem::size_of_val(&JMPBUF) == mem::size_of::<Box<JmpBuf>>());
+            assert!(mem::replace(&mut JMPBUF, Some(Box::new([0; JBLEN]))).is_none(), "Only one `Window` is supported on iOS");
+        }
+
+        unsafe {
+            if setjmp(mem::transmute_copy(&mut JMPBUF)) != 0 {
+                let app_class = class!(UIApplication);
+                let app: id = msg_send![app_class, sharedApplication];
+                let delegate: id = msg_send![app, delegate];
+                let state: *mut c_void = *(&*delegate).get_ivar("winitState");
+                let mut delegate_state = Box::from_raw(state as *mut DelegateState);
+                let events_queue = &*ev.events_queue;
+                (&mut *delegate).set_ivar("eventsQueue", mem::transmute::<_, *mut c_void>(events_queue));
+
+                // easiest? way to get access to PlatformSpecificWindowBuilderAttributes to configure the view
+                let rect: CGRect = msg_send![MonitorId.get_uiscreen(), bounds];
+
+                let uiview_class = class!(UIView);
+                let root_view_class = pl_attributes.root_view_class;
+                let is_uiview: BOOL = msg_send![root_view_class, isSubclassOfClass:uiview_class];
+                assert!(is_uiview == YES, "`root_view_class` must inherit from `UIView`");
+
+                delegate_state.view = msg_send![root_view_class, alloc];
+                assert!(!delegate_state.view.is_null(), "Failed to create `UIView` instance");
+                delegate_state.view = msg_send![delegate_state.view, initWithFrame:rect];
+                assert!(!delegate_state.view.is_null(), "Failed to initialize `UIView` instance");
+
+                let _: () = msg_send![delegate_state.controller, setView:delegate_state.view];
+                let _: () = msg_send![delegate_state.window, makeKeyAndVisible];
+
+                return Ok(Window {
+                    _events_queue: ev.events_queue.clone(),
+                    delegate_state,
+                });
+            }
+        }
+
+        create_delegate_class();
+        start_app();
+
+        panic!("Couldn't create `UIApplication`!")
     }
 
     #[inline]
     pub fn get_uiwindow(&self) -> id {
-        unsafe { (*self.delegate_state).window }
+        self.delegate_state.window
     }
 
     #[inline]
     pub fn get_uiview(&self) -> id {
-        unsafe { (*self.delegate_state).view }
+        self.delegate_state.view
     }
 
     #[inline]
@@ -359,7 +402,7 @@ impl Window {
 
     #[inline]
     pub fn get_inner_size(&self) -> Option<LogicalSize> {
-        unsafe { Some((&*self.delegate_state).size) }
+        Some(self.delegate_state.size)
     }
 
     #[inline]
@@ -404,7 +447,7 @@ impl Window {
 
     #[inline]
     pub fn get_hidpi_factor(&self) -> f64 {
-        unsafe { (&*self.delegate_state) }.scale
+        self.delegate_state.scale
     }
 
     #[inline]
@@ -469,10 +512,9 @@ impl Window {
 
 fn create_delegate_class() {
     extern fn did_finish_launching(this: &mut Object, _: Sel, _: id, _: id) -> BOOL {
-        let screen_class = Class::get("UIScreen").expect("Failed to get class `UIScreen`");
-        let window_class = Class::get("UIWindow").expect("Failed to get class `UIWindow`");
-        let controller_class = Class::get("MainViewController").expect("Failed to get class `MainViewController`");
-        let view_class = Class::get("MainView").expect("Failed to get class `MainView`");
+        let screen_class = class!(UIScreen);
+        let window_class = class!(UIWindow);
+        let controller_class = class!(UIViewController);
         unsafe {
             let main_screen: id = msg_send![screen_class, mainScreen];
             let bounds: CGRect = msg_send![main_screen, bounds];
@@ -486,30 +528,28 @@ fn create_delegate_class() {
             let view_controller: id = msg_send![controller_class, alloc];
             let view_controller: id = msg_send![view_controller, init];
 
-            let view: id = msg_send![view_class, alloc];
-            let view: id = msg_send![view, initForGl:&bounds];
-
             let _: () = msg_send![window, setRootViewController:view_controller];
-            let _: () = msg_send![window, makeKeyAndVisible];
 
-            let state = Box::new(DelegateState::new(window, view_controller, view, size, scale as f64));
+            let state = Box::new(DelegateState::new(window, view_controller, ptr::null_mut(), size, scale as f64));
             let state_ptr: *mut DelegateState = mem::transmute(state);
             this.set_ivar("winitState", state_ptr as *mut c_void);
 
+            // The `UIView` is setup in `Window::new` which gets `longjmp`'ed to here.
+            // This makes it easier to configure the specific `UIView` type.
             let _: () = msg_send![this, performSelector:sel!(postLaunch:) withObject:nil afterDelay:0.0];
         }
         YES
     }
 
     extern fn post_launch(_: &Object, _: Sel, _: id) {
-        unsafe { longjmp(mem::transmute(&mut JMPBUF),1); }
+        unsafe { longjmp(mem::transmute_copy(&mut JMPBUF), 1); }
     }
 
     extern fn did_become_active(this: &Object, _: Sel, _: id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
-            state.events_queue.push_back(Event::WindowEvent {
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
+            events_queue.borrow_mut().push_back(Event::WindowEvent {
                 window_id: RootEventId(WindowId),
                 event: WindowEvent::Focused(true),
             });
@@ -518,9 +558,9 @@ fn create_delegate_class() {
 
     extern fn will_resign_active(this: &Object, _: Sel, _: id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
-            state.events_queue.push_back(Event::WindowEvent {
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
+            events_queue.borrow_mut().push_back(Event::WindowEvent {
                 window_id: RootEventId(WindowId),
                 event: WindowEvent::Focused(false),
             });
@@ -529,38 +569,38 @@ fn create_delegate_class() {
 
     extern fn will_enter_foreground(this: &Object, _: Sel, _: id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
-            state.events_queue.push_back(Event::Suspended(false));
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
+            events_queue.borrow_mut().push_back(Event::Suspended(false));
         }
     }
 
     extern fn did_enter_background(this: &Object, _: Sel, _: id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
-            state.events_queue.push_back(Event::Suspended(true));
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
+            events_queue.borrow_mut().push_back(Event::Suspended(true));
         }
     }
 
     extern fn will_terminate(this: &Object, _: Sel, _: id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
             // push event to the front to garantee that we'll process it
             // immidiatly after jump
-            state.events_queue.push_front(Event::WindowEvent {
+            events_queue.borrow_mut().push_front(Event::WindowEvent {
                 window_id: RootEventId(WindowId),
                 event: WindowEvent::Destroyed,
             });
-            longjmp(mem::transmute(&mut JMPBUF),1);
+            longjmp(mem::transmute_copy(&mut JMPBUF), 1);
         }
     }
 
     extern fn handle_touches(this: &Object, _: Sel, touches: id, _:id) {
         unsafe {
-            let state: *mut c_void = *this.get_ivar("winitState");
-            let state = &mut *(state as *mut DelegateState);
+            let events_queue: *mut c_void = *this.get_ivar("eventsQueue");
+            let events_queue = &*(events_queue as *const RefCell<VecDeque<Event>>);
 
             let touches_enum: id = msg_send![touches, objectEnumerator];
 
@@ -573,7 +613,7 @@ fn create_delegate_class() {
                 let touch_id = touch as u64;
                 let phase: i32 = msg_send![touch, phase];
 
-                state.events_queue.push_back(Event::WindowEvent {
+                events_queue.borrow_mut().push_back(Event::WindowEvent {
                     window_id: RootEventId(WindowId),
                     event: WindowEvent::Touch(Touch {
                         device_id: DEVICE_ID,
@@ -593,7 +633,7 @@ fn create_delegate_class() {
         }
     }
 
-    let ui_responder = Class::get("UIResponder").expect("Failed to get class `UIResponder`");
+    let ui_responder = class!(UIResponder);
     let mut decl = ClassDecl::new("AppDelegate", ui_responder).expect("Failed to declare class `AppDelegate`");
 
     unsafe {
@@ -633,46 +673,12 @@ fn create_delegate_class() {
                         post_launch as extern fn(&Object, Sel, id));
 
         decl.add_ivar::<*mut c_void>("winitState");
+        decl.add_ivar::<*mut c_void>("eventsQueue");
 
         decl.register();
     }
 }
 
-// TODO: winit shouldn't contain GL-specfiic code
-pub fn create_view_class() {
-    let superclass = Class::get("UIViewController").expect("Failed to get class `UIViewController`");
-    let decl = ClassDecl::new("MainViewController", superclass).expect("Failed to declare class `MainViewController`");
-    decl.register();
-
-    extern fn init_for_gl(this: &Object, _: Sel, frame: *const c_void) -> id {
-        unsafe {
-            let bounds = frame as *const CGRect;
-            let view: id = msg_send![this, initWithFrame:(*bounds).clone()];
-
-            let mask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-            let _: () = msg_send![view, setAutoresizingMask:mask];
-            let _: () = msg_send![view, setAutoresizesSubviews:YES];
-
-            let layer: id = msg_send![view, layer];
-            let _ : () = msg_send![layer, setOpaque:YES];
-
-            view
-        }
-    }
-
-    extern fn layer_class(_: &Class, _: Sel) -> *const Class {
-        unsafe { mem::transmute(Class::get("CAEAGLLayer").expect("Failed to get class `CAEAGLLayer`")) }
-    }
-
-    let superclass = Class::get("GLKView").expect("Failed to get class `GLKView`");
-    let mut decl = ClassDecl::new("MainView", superclass).expect("Failed to declare class `MainView`");
-    unsafe {
-        decl.add_method(sel!(initForGl:), init_for_gl as extern fn(&Object, Sel, *const c_void) -> id);
-        decl.add_class_method(sel!(layerClass), layer_class as extern fn(&Class, Sel) -> *const Class);
-        decl.register();
-    }
-}
-
 #[inline]
 fn start_app() {
     unsafe {

src/platform/linux/dlopen.rs

@@ -1,4 +1,4 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 #![allow(dead_code)]
 
 use std::os::raw::{c_void, c_char, c_int};

src/platform/linux/mod.rs

@@ -1,4 +1,4 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 
 use std::collections::VecDeque;
 use std::{env, mem};

src/platform/linux/wayland/mod.rs

@@ -1,5 +1,5 @@
 #![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd",
-           target_os = "openbsd"))]
+           target_os = "netbsd", target_os = "openbsd"))]
 
 pub use self::window::Window;
 pub use self::event_loop::{EventsLoop, EventsLoopProxy, EventsLoopSink, MonitorId};

src/platform/linux/x11/mod.rs

@@ -1,4 +1,4 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 
 pub mod ffi;
 mod events;
@@ -482,36 +482,37 @@ impl EventsLoop {
                         shared_state_lock.position.unwrap()
                     };
 
-                    // If we don't use the existing adjusted value when available, then the user can screw up the
-                    // resizing by dragging across monitors *without* dropping the window.
-                    let (width, height) = shared_state_lock.dpi_adjusted
-                        .unwrap_or_else(|| (xev.width as f64, xev.height as f64));
-                    let last_hidpi_factor = if shared_state_lock.is_new_window {
-                        shared_state_lock.is_new_window = false;
-                        1.0
-                    } else {
-                        shared_state_lock.last_monitor
-                            .as_ref()
-                            .map(|last_monitor| last_monitor.hidpi_factor)
-                            .unwrap_or(1.0)
-                    };
-                    let new_hidpi_factor = {
-                        let window_rect = util::Rect::new(new_outer_position, new_inner_size);
-                        let monitor = self.xconn.get_monitor_for_window(Some(window_rect));
-                        let new_hidpi_factor = monitor.hidpi_factor;
-                        shared_state_lock.last_monitor = Some(monitor);
-                        new_hidpi_factor
-                    };
-                    if last_hidpi_factor != new_hidpi_factor {
-                        events.dpi_changed = Some(WindowEvent::HiDpiFactorChanged(new_hidpi_factor));
-                        let (new_width, new_height, flusher) = window.adjust_for_dpi(
-                            last_hidpi_factor,
-                            new_hidpi_factor,
-                            width,
-                            height,
-                        );
-                        flusher.queue();
-                        shared_state_lock.dpi_adjusted = Some((new_width, new_height));
+                    if is_synthetic {
+                        // If we don't use the existing adjusted value when available, then the user can screw up the
+                        // resizing by dragging across monitors *without* dropping the window.
+                        let (width, height) = shared_state_lock.dpi_adjusted
+                            .unwrap_or_else(|| (xev.width as f64, xev.height as f64));
+                        let last_hidpi_factor = shared_state_lock.guessed_dpi
+                            .take()
+                            .unwrap_or_else(|| {
+                                shared_state_lock.last_monitor
+                                    .as_ref()
+                                    .map(|last_monitor| last_monitor.hidpi_factor)
+                                    .unwrap_or(1.0)
+                            });
+                        let new_hidpi_factor = {
+                            let window_rect = util::AaRect::new(new_outer_position, new_inner_size);
+                            let monitor = self.xconn.get_monitor_for_window(Some(window_rect));
+                            let new_hidpi_factor = monitor.hidpi_factor;
+                            shared_state_lock.last_monitor = Some(monitor);
+                            new_hidpi_factor
+                        };
+                        if last_hidpi_factor != new_hidpi_factor {
+                            events.dpi_changed = Some(WindowEvent::HiDpiFactorChanged(new_hidpi_factor));
+                            let (new_width, new_height, flusher) = window.adjust_for_dpi(
+                                last_hidpi_factor,
+                                new_hidpi_factor,
+                                width,
+                                height,
+                            );
+                            flusher.queue();
+                            shared_state_lock.dpi_adjusted = Some((new_width, new_height));
+                        }
                     }
 
                     events
@@ -592,7 +593,7 @@ impl EventsLoop {
 
                 // Standard virtual core keyboard ID. XInput2 needs to be used to get a reliable
                 // value, though this should only be an issue under multiseat configurations.
-                let device = 3;
+                let device = util::VIRTUAL_CORE_KEYBOARD;
                 let device_id = mkdid(device);
 
                 // When a compose sequence or IME pre-edit is finished, it ends in a KeyPress with

src/platform/linux/x11/monitor.rs

@@ -55,7 +55,7 @@ pub struct MonitorId {
     /// The DPI scale factor
     pub(crate) hidpi_factor: f64,
     /// Used to determine which windows are on this monitor
-    pub(crate) rect: util::Rect,
+    pub(crate) rect: util::AaRect,
 }
 
 impl MonitorId {
@@ -68,7 +68,7 @@ impl MonitorId {
     ) -> Self {
         let (name, hidpi_factor) = unsafe { xconn.get_output_info(resources, &repr) };
         let (dimensions, position) = unsafe { (repr.get_dimensions(), repr.get_position()) };
-        let rect = util::Rect::new(position, dimensions);
+        let rect = util::AaRect::new(position, dimensions);
         MonitorId {
             id,
             name,
@@ -104,7 +104,7 @@ impl MonitorId {
 }
 
 impl XConnection {
-    pub fn get_monitor_for_window(&self, window_rect: Option<util::Rect>) -> MonitorId {
+    pub fn get_monitor_for_window(&self, window_rect: Option<util::AaRect>) -> MonitorId {
         let monitors = self.get_available_monitors();
         let default = monitors
             .get(0)

src/platform/linux/x11/util/format.rs

@@ -50,7 +50,7 @@ pub trait Formattable: Debug + Clone + Copy + PartialEq + PartialOrd {
 }
 
 // You might be surprised by the absence of c_int, but not as surprised as X11 would be by the presence of it.
-impl Formattable for c_char { const FORMAT: Format = Format::Char; }
+impl Formattable for c_schar { const FORMAT: Format = Format::Char; }
 impl Formattable for c_uchar { const FORMAT: Format = Format::Char; }
 impl Formattable for c_short { const FORMAT: Format = Format::Short; }
 impl Formattable for c_ushort { const FORMAT: Format = Format::Short; }

src/platform/linux/x11/util/geometry.rs

@@ -3,34 +3,34 @@ use std::cmp;
 use super::*;
 use {LogicalPosition, LogicalSize};
 
+// Friendly neighborhood axis-aligned rectangle
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Rect {
-    left: i64,
-    right: i64,
-    top: i64,
-    bottom: i64,
+pub struct AaRect {
+    x: i64,
+    y: i64,
+    width: i64,
+    height: i64,
 }
 
-impl Rect {
+impl AaRect {
     pub fn new((x, y): (i32, i32), (width, height): (u32, u32)) -> Self {
         let (x, y) = (x as i64, y as i64);
         let (width, height) = (width as i64, height as i64);
-        Rect {
-            left: x,
-            right: x + width,
-            top: y,
-            bottom: y + height,
-        }
+        AaRect { x, y, width, height }
+    }
+
+    pub fn contains_point(&self, x: i64, y: i64) -> bool {
+        x >= self.x && x <= self.x + self.width && y >= self.y && y <= self.y + self.height
     }
 
     pub fn get_overlapping_area(&self, other: &Self) -> i64 {
         let x_overlap = cmp::max(
             0,
-            cmp::min(self.right, other.right) - cmp::max(self.left, other.left),
+            cmp::min(self.x + self.width, other.x + other.width) - cmp::max(self.x, other.x),
         );
         let y_overlap = cmp::max(
             0,
-            cmp::min(self.bottom, other.bottom) - cmp::max(self.top, other.top),
+            cmp::min(self.y + self.height, other.y + other.height) - cmp::max(self.y, other.y),
         );
         x_overlap * y_overlap
     }

src/platform/linux/x11/util/input.rs

@@ -3,6 +3,9 @@ use std::str;
 use super::*;
 use events::ModifiersState;
 
+pub const VIRTUAL_CORE_POINTER: c_int = 2;
+pub const VIRTUAL_CORE_KEYBOARD: c_int = 3;
+
 // A base buffer size of 1kB uses a negligible amount of RAM while preventing us from having to
 // re-allocate (and make another round-trip) in the *vast* majority of cases.
 // To test if `lookup_utf8` works correctly, set this to 1.
@@ -24,8 +27,8 @@ pub struct PointerState<'a> {
     xconn: &'a XConnection,
     root: ffi::Window,
     child: ffi::Window,
-    root_x: c_double,
-    root_y: c_double,
+    pub root_x: c_double,
+    pub root_y: c_double,
     win_x: c_double,
     win_y: c_double,
     buttons: ffi::XIButtonState,

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

@@ -24,6 +24,7 @@ pub fn calc_dpi_factor(
 
     // See http://xpra.org/trac/ticket/728 for more information.
     if width_mm == 0 || width_mm == 0 {
+        warn!("XRandR reported that the display's 0mm in size, which is certifiably insane");
         return 1.0;
     }
 

src/platform/linux/x11/window.rs

@@ -29,13 +29,12 @@ unsafe extern "C" fn visibility_predicate(
 
 #[derive(Debug, Default)]
 pub struct SharedState {
-    // Window creation assumes a DPI factor of 1.0, so we use this flag to handle that special case.
-    pub is_new_window: bool,
     pub cursor_pos: Option<(f64, f64)>,
     pub size: Option<(u32, u32)>,
     pub position: Option<(i32, i32)>,
     pub inner_position: Option<(i32, i32)>,
     pub inner_position_rel_parent: Option<(i32, i32)>,
+    pub guessed_dpi: Option<f64>,
     pub last_monitor: Option<X11MonitorId>,
     pub dpi_adjusted: Option<(f64, f64)>,
     // Used to restore position after exiting fullscreen.
@@ -46,9 +45,9 @@ pub struct SharedState {
 }
 
 impl SharedState {
-    fn new() -> Mutex<Self> {
+    fn new(dpi_factor: f64) -> Mutex<Self> {
         let mut shared_state = SharedState::default();
-        shared_state.is_new_window = true;
+        shared_state.guessed_dpi = Some(dpi_factor);
         Mutex::new(shared_state)
     }
 }
@@ -78,15 +77,51 @@ impl UnownedWindow {
         let xconn = &event_loop.xconn;
         let root = event_loop.root;
 
-        let max_dimensions: Option<(u32, u32)> = window_attrs.max_dimensions.map(Into::into);
-        let min_dimensions: Option<(u32, u32)> = window_attrs.min_dimensions.map(Into::into);
+        let monitors = xconn.get_available_monitors();
+        let dpi_factor = if !monitors.is_empty() {
+            let mut dpi_factor = Some(monitors[0].get_hidpi_factor());
+            for monitor in &monitors {
+                if Some(monitor.get_hidpi_factor()) != dpi_factor {
+                    dpi_factor = None;
+                }
+            }
+            dpi_factor.unwrap_or_else(|| {
+                xconn.query_pointer(root, util::VIRTUAL_CORE_POINTER)
+                    .ok()
+                    .and_then(|pointer_state| {
+                        let (x, y) = (pointer_state.root_x as i64, pointer_state.root_y as i64);
+                        let mut dpi_factor = None;
+                        for monitor in &monitors {
+                            if monitor.rect.contains_point(x, y) {
+                                dpi_factor = Some(monitor.get_hidpi_factor());
+                                break;
+                            }
+                        }
+                        dpi_factor
+                    })
+                    .unwrap_or(1.0)
+            })
+        } else {
+            return Err(OsError(format!("No monitors were detected.")));
+        };
+
+        info!("Guessed window DPI factor: {}", dpi_factor);
+
+        let max_dimensions: Option<(u32, u32)> = window_attrs.max_dimensions.map(|size| {
+            size.to_physical(dpi_factor).into()
+        });
+        let min_dimensions: Option<(u32, u32)> = window_attrs.min_dimensions.map(|size| {
+            size.to_physical(dpi_factor).into()
+        });
 
         let dimensions = {
             // x11 only applies constraints when the window is actively resized
             // by the user, so we have to manually apply the initial constraints
-            let mut dimensions = window_attrs.dimensions
+            let mut dimensions: (u32, u32) = window_attrs.dimensions
+                .or_else(|| Some((800, 600).into()))
+                .map(|size| size.to_physical(dpi_factor))
                 .map(Into::into)
-                .unwrap_or((800, 600));
+                .unwrap();
             if let Some(max) = max_dimensions {
                 dimensions.0 = cmp::min(dimensions.0, max.0);
                 dimensions.1 = cmp::min(dimensions.1, max.1);
@@ -95,6 +130,7 @@ impl UnownedWindow {
                 dimensions.0 = cmp::max(dimensions.0, min.0);
                 dimensions.1 = cmp::max(dimensions.1, min.1);
             }
+            debug!("Calculated physical dimensions: {}x{}", dimensions.0, dimensions.1);
             dimensions
         };
 
@@ -166,7 +202,7 @@ impl UnownedWindow {
             cursor_hidden: Default::default(),
             ime_sender: Mutex::new(event_loop.ime_sender.clone()),
             multitouch: window_attrs.multitouch,
-            shared_state: SharedState::new(),
+            shared_state: SharedState::new(dpi_factor),
         };
 
         // Title must be set before mapping. Some tiling window managers (i.e. i3) use the window
@@ -240,13 +276,17 @@ impl UnownedWindow {
             {
                 let mut min_dimensions = window_attrs.min_dimensions;
                 let mut max_dimensions = window_attrs.max_dimensions;
-                if !window_attrs.resizable && !util::wm_name_is_one_of(&["Xfwm4"]) {
-                    max_dimensions = Some(dimensions.into());
-                    min_dimensions = Some(dimensions.into());
+                if !window_attrs.resizable {
+                    if util::wm_name_is_one_of(&["Xfwm4"]) {
+                        warn!("To avoid a WM bug, disabling resizing has no effect on Xfwm4");
+                    } else {
+                        max_dimensions = Some(dimensions.into());
+                        min_dimensions = Some(dimensions.into());
 
-                    let mut shared_state_lock = window.shared_state.lock();
-                    shared_state_lock.min_dimensions = window_attrs.min_dimensions;
-                    shared_state_lock.max_dimensions = window_attrs.max_dimensions;
+                        let mut shared_state_lock = window.shared_state.lock();
+                        shared_state_lock.min_dimensions = window_attrs.min_dimensions;
+                        shared_state_lock.max_dimensions = window_attrs.max_dimensions;
+                    }
                 }
 
                 let mut normal_hints = util::NormalHints::new(xconn);
@@ -482,10 +522,10 @@ impl UnownedWindow {
         self.invalidate_cached_frame_extents();
     }
 
-    fn get_rect(&self) -> Option<util::Rect> {
+    fn get_rect(&self) -> Option<util::AaRect> {
         // TODO: This might round-trip more times than needed.
         if let (Some(position), Some(size)) = (self.get_position_physical(), self.get_outer_size_physical()) {
-            Some(util::Rect::new(position, size))
+            Some(util::AaRect::new(position, size))
         } else {
             None
         }
@@ -853,6 +893,7 @@ impl UnownedWindow {
             // Making the window unresizable on Xfwm prevents further changes to `WM_NORMAL_HINTS` from being detected.
             // This makes it impossible for resizing to be re-enabled, and also breaks DPI scaling. As such, we choose
             // the lesser of two evils and do nothing.
+            warn!("To avoid a WM bug, disabling resizing has no effect on Xfwm4");
             return;
         }
 

src/platform/macos/events_loop.rs

@@ -180,7 +180,7 @@ impl EventsLoop {
         where F: FnMut(Event),
     {
         unsafe {
-            if !msg_send![cocoa::base::class("NSThread"), isMainThread] {
+            if !msg_send![class!(NSThread), isMainThread] {
                 panic!("Events can only be polled from the main thread on macOS");
             }
         }
@@ -221,7 +221,7 @@ impl EventsLoop {
         where F: FnMut(Event) -> ControlFlow
     {
         unsafe {
-            if !msg_send![cocoa::base::class("NSThread"), isMainThread] {
+            if !msg_send![class!(NSThread), isMainThread] {
                 panic!("Events can only be polled from the main thread on macOS");
             }
         }
@@ -674,11 +674,15 @@ pub fn event_mods(event: cocoa::base::id) -> ModifiersState {
 unsafe fn modifier_event(
     ns_event: cocoa::base::id,
     keymask: NSEventModifierFlags,
-    key_pressed: bool,
+    was_key_pressed: bool,
 ) -> Option<WindowEvent> {
-    if !key_pressed && NSEvent::modifierFlags(ns_event).contains(keymask)
-    || key_pressed && !NSEvent::modifierFlags(ns_event).contains(keymask) {
-        let state = ElementState::Released;
+    if !was_key_pressed && NSEvent::modifierFlags(ns_event).contains(keymask)
+    || was_key_pressed && !NSEvent::modifierFlags(ns_event).contains(keymask) {
+        let state = if was_key_pressed {
+            ElementState::Released
+        } else {
+            ElementState::Pressed
+        };
         let keycode = NSEvent::keyCode(ns_event);
         let scancode = keycode as u32;
         let virtual_keycode = to_virtual_key_code(keycode);

src/platform/macos/ffi.rs

@@ -2,7 +2,7 @@
 
 #![allow(dead_code, non_snake_case, non_upper_case_globals)]
 
-use cocoa::base::{class, id};
+use cocoa::base::id;
 use cocoa::foundation::{NSInteger, NSUInteger};
 use objc;
 
@@ -35,7 +35,7 @@ unsafe impl objc::Encode for NSRange {
 
 pub trait NSMutableAttributedString: Sized {
     unsafe fn alloc(_: Self) -> id {
-        msg_send![class("NSMutableAttributedString"), alloc]
+        msg_send![class!(NSMutableAttributedString), alloc]
     }
 
     unsafe fn init(self) -> id; // *mut NSMutableAttributedString

src/platform/macos/util.rs

@@ -1,5 +1,5 @@
 use cocoa::appkit::NSWindowStyleMask;
-use cocoa::base::{class, id, nil};
+use cocoa::base::{id, nil};
 use cocoa::foundation::{NSRect, NSUInteger};
 use core_graphics::display::CGDisplay;
 
@@ -26,13 +26,13 @@ pub unsafe fn set_style_mask(window: id, view: id, mask: NSWindowStyleMask) {
 }
 
 pub unsafe fn create_input_context(view: id) -> IdRef {
-    let input_context: id = msg_send![class("NSTextInputContext"), alloc];
+    let input_context: id = msg_send![class!(NSTextInputContext), alloc];
     let input_context: id = msg_send![input_context, initWithClient:view];
     IdRef::new(input_context)
 }
 
 #[allow(dead_code)]
 pub unsafe fn open_emoji_picker() {
-    let app: id = msg_send![class("NSApplication"), sharedApplication];
+    let app: id = msg_send![class!(NSApplication), sharedApplication];
     let _: () = msg_send![app, orderFrontCharacterPalette:nil];
 }

src/platform/macos/view.rs

@@ -7,7 +7,7 @@ use std::collections::VecDeque;
 use std::os::raw::*;
 use std::sync::Weak;
 
-use cocoa::base::{class, id, nil};
+use cocoa::base::{id, nil};
 use cocoa::appkit::{NSEvent, NSView, NSWindow};
 use cocoa::foundation::{NSPoint, NSRect, NSSize, NSString, NSUInteger};
 use objc::declare::ClassDecl;
@@ -64,7 +64,7 @@ unsafe impl Sync for ViewClass {}
 
 lazy_static! {
     static ref VIEW_CLASS: ViewClass = unsafe {
-        let superclass = Class::get("NSView").unwrap();
+        let superclass = class!(NSView);
         let mut decl = ClassDecl::new("WinitView", superclass).unwrap();
         decl.add_method(sel!(dealloc), dealloc as extern fn(&Object, Sel));
         decl.add_method(
@@ -191,7 +191,7 @@ extern fn set_marked_text(
         let marked_text_ref: &mut id = this.get_mut_ivar("markedText");
         let _: () = msg_send![(*marked_text_ref), release];
         let marked_text = NSMutableAttributedString::alloc(nil);
-        let has_attr = msg_send![string, isKindOfClass:class("NSAttributedString")];
+        let has_attr = msg_send![string, isKindOfClass:class!(NSAttributedString)];
         if has_attr {
             marked_text.initWithAttributedString(string);
         } else {
@@ -214,7 +214,7 @@ extern fn unmark_text(this: &Object, _sel: Sel) {
 
 extern fn valid_attributes_for_marked_text(_this: &Object, _sel: Sel) -> id {
     //println!("validAttributesForMarkedText");
-    unsafe { msg_send![class("NSArray"), array] }
+    unsafe { msg_send![class!(NSArray), array] }
 }
 
 extern fn attributed_substring_for_proposed_range(
@@ -265,7 +265,7 @@ extern fn insert_text(this: &Object, _sel: Sel, string: id, _replacement_range:
         let state_ptr: *mut c_void = *this.get_ivar("winitState");
         let state = &mut *(state_ptr as *mut ViewState);
 
-        let has_attr = msg_send![string, isKindOfClass:class("NSAttributedString")];
+        let has_attr = msg_send![string, isKindOfClass:class!(NSAttributedString)];
         let characters = if has_attr {
             // This is a *mut NSAttributedString
             msg_send![string, string]
@@ -282,7 +282,7 @@ extern fn insert_text(this: &Object, _sel: Sel, string: id, _replacement_range:
         state.last_insert = Some(string.to_owned());
 
         // We don't need this now, but it's here if that changes.
-        //let event: id = msg_send![class("NSApp"), currentEvent];
+        //let event: id = msg_send![class!(NSApp), currentEvent];
 
         let mut events = VecDeque::with_capacity(characters.len());
         for character in string.chars() {
@@ -400,7 +400,7 @@ extern fn key_down(this: &Object, _sel: Sel, event: id) {
                 // Some keys (and only *some*, with no known reason) don't trigger `insertText`, while others do...
                 // So, we don't give repeats the opportunity to trigger that, since otherwise our hack will cause some
                 // keys to generate twice as many characters.
-                let array: id = msg_send![class("NSArray"), arrayWithObject:event];
+                let array: id = msg_send![class!(NSArray), arrayWithObject:event];
                 let (): _ = msg_send![this, interpretKeyEvents:array];
             }
         }

src/platform/macos/window.rs

@@ -1,8 +1,9 @@
 use std;
+use std::cell::{Cell, RefCell};
 use std::ops::Deref;
 use std::os::raw::c_void;
 use std::sync::Weak;
-use std::cell::{Cell, RefCell};
+use std::sync::atomic::{Ordering, AtomicBool};
 
 use cocoa;
 use cocoa::appkit::{
@@ -45,6 +46,7 @@ use window::MonitorId as RootMonitorId;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Id(pub usize);
 
+// TODO: It's possible for delegate methods to be called asynchronously, causing data races / `RefCell` panics.
 pub struct DelegateState {
     view: IdRef,
     window: IdRef,
@@ -421,7 +423,7 @@ impl WindowDelegate {
 
         INIT.call_once(|| unsafe {
             // Create new NSWindowDelegate
-            let superclass = Class::get("NSObject").unwrap();
+            let superclass = class!(NSObject);
             let mut decl = ClassDecl::new("WinitWindowDelegate", superclass).unwrap();
 
             // Add callback methods
@@ -526,7 +528,7 @@ pub struct Window2 {
     pub window: IdRef,
     pub delegate: WindowDelegate,
     pub input_context: IdRef,
-    cursor_hidden: Cell<bool>,
+    cursor_hidden: AtomicBool,
 }
 
 unsafe impl Send for Window2 {}
@@ -591,7 +593,7 @@ impl Window2 {
         pl_attribs: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Window2, CreationError> {
         unsafe {
-            if !msg_send![cocoa::base::class("NSThread"), isMainThread] {
+            if !msg_send![class!(NSThread), isMainThread] {
                 panic!("Windows can only be created on the main thread on macOS");
             }
         }
@@ -728,7 +730,7 @@ impl Window2 {
         static INIT: std::sync::Once = std::sync::ONCE_INIT;
 
         INIT.call_once(|| unsafe {
-            let window_superclass = Class::get("NSWindow").unwrap();
+            let window_superclass = class!(NSWindow);
             let mut decl = ClassDecl::new("WinitWindow", window_superclass).unwrap();
             decl.add_method(sel!(canBecomeMainWindow), yes as extern fn(&Object, Sel) -> BOOL);
             decl.add_method(sel!(canBecomeKeyWindow), yes as extern fn(&Object, Sel) -> BOOL);
@@ -987,7 +989,7 @@ impl Window2 {
             MouseCursor::ZoomOut => "arrowCursor",
         };
         let sel = Sel::register(cursor_name);
-        let cls = Class::get("NSCursor").unwrap();
+        let cls = class!(NSCursor);
         unsafe {
             use objc::Message;
             let cursor: id = cls.send_message(sel, ()).unwrap();
@@ -1004,16 +1006,16 @@ impl Window2 {
 
     #[inline]
     pub fn hide_cursor(&self, hide: bool) {
-        let cursor_class = Class::get("NSCursor").unwrap();
+        let cursor_class = class!(NSCursor);
         // macOS uses a "hide counter" like Windows does, so we avoid incrementing it more than once.
         // (otherwise, `hide_cursor(false)` would need to be called n times!)
-        if hide != self.cursor_hidden.get() {
+        if hide != self.cursor_hidden.load(Ordering::Acquire) {
             if hide {
                 let _: () = unsafe { msg_send![cursor_class, hide] };
             } else {
                 let _: () = unsafe { msg_send![cursor_class, unhide] };
             }
-            self.cursor_hidden.replace(hide);
+            self.cursor_hidden.store(hide, Ordering::Release);
         }
     }
 

src/platform/mod.rs

@@ -3,7 +3,7 @@ pub use self::platform::*;
 #[cfg(target_os = "windows")]
 #[path="windows/mod.rs"]
 mod platform;
-#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 #[path="linux/mod.rs"]
 mod platform;
 #[cfg(target_os = "macos")]
@@ -21,5 +21,6 @@ mod platform;
 
 #[cfg(all(not(target_os = "ios"), not(target_os = "windows"), not(target_os = "linux"),
   not(target_os = "macos"), not(target_os = "android"), not(target_os = "dragonfly"),
-  not(target_os = "freebsd"), not(target_os = "openbsd"), not(target_os = "emscripten")))]
+  not(target_os = "freebsd"), not(target_os = "netbsd"), not(target_os = "openbsd"),
+  not(target_os = "emscripten")))]
 compile_error!("The platform you're compiling for is not supported by winit");

src/platform/windows/dpi.rs

@@ -8,7 +8,6 @@ use winapi::shared::minwindef::{BOOL, UINT, FALSE};
 use winapi::shared::windef::{
     DPI_AWARENESS_CONTEXT,
     DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE,
-    HDC,
     HMONITOR,
     HWND,
 };
@@ -145,7 +144,11 @@ pub fn dpi_to_scale_factor(dpi: u32) -> f64 {
     dpi as f64 / BASE_DPI as f64
 }
 
-pub unsafe fn get_window_dpi(hwnd: HWND, hdc: HDC) -> u32 {
+pub unsafe fn get_hwnd_dpi(hwnd: HWND) -> u32 {
+    let hdc = winuser::GetDC(hwnd);
+    if hdc.is_null() {
+        panic!("[winit] `GetDC` returned null!");
+    }
     if let Some(GetDpiForWindow) = *GET_DPI_FOR_WINDOW {
         // We are on Windows 10 Anniversary Update (1607) or later.
         match GetDpiForWindow(hwnd) {
@@ -181,16 +184,6 @@ pub unsafe fn get_window_dpi(hwnd: HWND, hdc: HDC) -> u32 {
     }
 }
 
-// Use this when you have both the HWND and HDC on hand (i.e. window methods)
-pub fn get_window_scale_factor(hwnd: HWND, hdc: HDC) -> f64 {
-    dpi_to_scale_factor(unsafe { get_window_dpi(hwnd, hdc) })
-}
-
-// Use this when you only have the HWND (i.e. event handling)
 pub fn get_hwnd_scale_factor(hwnd: HWND) -> f64 {
-    let hdc = unsafe { winuser::GetDC(hwnd) };
-    if hdc.is_null() {
-        panic!("[winit] `GetDC` returned null!");
-    }
-    unsafe { get_window_scale_factor(hwnd, hdc) }
+    dpi_to_scale_factor(unsafe { get_hwnd_dpi(hwnd) })
 }

src/platform/windows/events_loop.rs

@@ -58,6 +58,7 @@ use platform::platform::dpi::{
     get_hwnd_scale_factor,
 };
 use platform::platform::event::{handle_extended_keys, process_key_params, vkey_to_winit_vkey};
+use platform::platform::icon::WinIcon;
 use platform::platform::raw_input::{get_raw_input_data, get_raw_mouse_button_state};
 use platform::platform::window::adjust_size;
 
@@ -94,6 +95,13 @@ pub struct WindowState {
     // This is different from the value in `SavedWindowInfo`! That one represents the DPI saved upon entering
     // fullscreen. This will always be the most recent DPI for the window.
     pub dpi_factor: f64,
+    pub fullscreen: Option<::MonitorId>,
+    pub window_icon: Option<WinIcon>,
+    pub taskbar_icon: Option<WinIcon>,
+    pub decorations: bool,
+    pub always_on_top: bool,
+    pub maximized: bool,
+    pub resizable: bool,
 }
 
 impl WindowState {
@@ -326,6 +334,11 @@ impl EventsLoopProxy {
     ///
     /// The `Inserted` can be used to inject a `WindowState` for the callback to use. The state is
     /// removed automatically if the callback receives a `WM_CLOSE` message for the window.
+    ///
+    /// Note that if you are using this to change some property of a window and updating
+    /// `WindowState` then you should call this within the lock of `WindowState`. Otherwise the
+    /// events may be sent to the other thread in different order to the one in which you set
+    /// `WindowState`, leaving them out of sync.
     pub fn execute_in_thread<F>(&self, function: F)
     where
         F: FnMut(Inserter) + Send + 'static,
@@ -357,7 +370,7 @@ lazy_static! {
         }
     };
     // Message sent when we want to execute a closure in the thread.
-    // WPARAM contains a Box<Box<FnMut()>> that must be retreived with `Box::from_raw`,
+    // WPARAM contains a Box<Box<FnMut()>> that must be retrieved with `Box::from_raw`,
     // and LPARAM is unused.
     static ref EXEC_MSG_ID: u32 = {
         unsafe {

src/platform/windows/icon.rs

@@ -22,11 +22,13 @@ pub enum IconType {
     Big = winuser::ICON_BIG as isize,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct WinIcon {
     pub handle: HICON,
 }
 
+unsafe impl Send for WinIcon {}
+
 impl WinIcon {
     #[allow(dead_code)]
     pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, util::WinError> {

src/platform/windows/monitor.rs

@@ -1,5 +1,6 @@
 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};
@@ -49,7 +50,7 @@ unsafe extern "system" fn monitor_enum_proc(
     TRUE // continue enumeration
 }
 
-fn get_available_monitors() -> VecDeque<MonitorId> {
+pub fn get_available_monitors() -> VecDeque<MonitorId> {
     let mut monitors: VecDeque<MonitorId> = VecDeque::new();
     unsafe {
         winuser::EnumDisplayMonitors(
@@ -62,7 +63,7 @@ fn get_available_monitors() -> VecDeque<MonitorId> {
     monitors
 }
 
-fn get_primary_monitor() -> MonitorId {
+pub fn get_primary_monitor() -> MonitorId {
     const ORIGIN: POINT = POINT { x: 0, y: 0 };
     let hmonitor = unsafe {
         winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY)
@@ -132,6 +133,14 @@ impl MonitorId {
         }
     }
 
+    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())

src/platform/windows/util.rs

@@ -2,8 +2,8 @@ use std::{self, mem, ptr, slice};
 use std::ops::BitAnd;
 
 use winapi::ctypes::wchar_t;
-use winapi::shared::minwindef::DWORD;
-use winapi::shared::windef::{HWND, RECT};
+use winapi::shared::minwindef::{BOOL, DWORD};
+use winapi::shared::windef::{HWND, POINT, RECT};
 use winapi::um::errhandlingapi::GetLastError;
 use winapi::um::winbase::{
     FormatMessageW,
@@ -38,15 +38,23 @@ pub fn wchar_ptr_to_string(wchar: *const wchar_t) -> String {
     wchar_to_string(wchar_slice)
 }
 
-pub fn get_window_rect(hwnd: HWND) -> Option<RECT> {
-    let mut rect: RECT = unsafe { mem::uninitialized() };
-    if unsafe { winuser::GetWindowRect(hwnd, &mut rect) } != 0 {
-        Some(rect)
+pub unsafe fn status_map<T, F: FnMut(&mut T) -> BOOL>(mut fun: F) -> Option<T> {
+    let mut data: T = mem::uninitialized();
+    if fun(&mut data) != 0 {
+        Some(data)
     } else {
         None
     }
 }
 
+pub fn get_cursor_pos() -> Option<POINT> {
+    unsafe { status_map(|cursor_pos| winuser::GetCursorPos(cursor_pos)) }
+}
+
+pub fn get_window_rect(hwnd: HWND) -> Option<RECT> {
+    unsafe { status_map(|rect| winuser::GetWindowRect(hwnd, rect)) }
+}
+
 // This won't be needed anymore if we just add a derive to winapi.
 pub fn rect_eq(a: &RECT, b: &RECT) -> bool {
     let left_eq = a.left == b.left;

src/platform/windows/window.rs

@@ -1,17 +1,17 @@
 #![cfg(target_os = "windows")]
 
-use std::cell::{Cell, RefCell};
-use std::ffi::OsStr;
 use std::{io, mem, ptr};
+use std::cell::Cell;
+use std::ffi::OsStr;
 use std::os::windows::ffi::OsStrExt;
 use std::sync::{Arc, Mutex};
 use std::sync::mpsc::channel;
 
 use winapi::ctypes::c_int;
 use winapi::shared::minwindef::{BOOL, DWORD, FALSE, LPARAM, TRUE, UINT, WORD, WPARAM};
-use winapi::shared::windef::{HDC, HWND, LPPOINT, POINT, RECT};
+use winapi::shared::windef::{HWND, LPPOINT, POINT, RECT};
 use winapi::um::{combaseapi, dwmapi, libloaderapi, winuser};
-use winapi::um::objbase::{COINIT_MULTITHREADED};
+use winapi::um::objbase::COINIT_MULTITHREADED;
 use winapi::um::shobjidl_core::{CLSID_TaskbarList, ITaskbarList2};
 use winapi::um::winnt::{LONG, LPCWSTR};
 
@@ -26,36 +26,28 @@ use {
     WindowAttributes,
 };
 use platform::platform::{Cursor, PlatformSpecificWindowBuilderAttributes, WindowId};
-use platform::platform::dpi::{BASE_DPI, dpi_to_scale_factor, get_window_dpi, get_window_scale_factor};
-use platform::platform::events_loop::{self, DESTROY_MSG_ID, EventsLoop, INITIAL_DPI_MSG_ID};
+use platform::platform::dpi::{dpi_to_scale_factor, get_hwnd_dpi};
+use platform::platform::events_loop::{self, EventsLoop, DESTROY_MSG_ID, INITIAL_DPI_MSG_ID};
+use platform::platform::events_loop::WindowState;
 use platform::platform::icon::{self, IconType, WinIcon};
+use platform::platform::monitor::get_available_monitors;
 use platform::platform::raw_input::register_all_mice_and_keyboards_for_raw_input;
 use platform::platform::util;
 
+const WS_RESIZABLE: DWORD = winuser::WS_SIZEBOX | winuser::WS_MAXIMIZEBOX;
+
 /// The Win32 implementation of the main `Window` object.
 pub struct Window {
     /// Main handle for the window.
     window: WindowWrapper,
 
-    decorations: Cell<bool>,
-    maximized: Cell<bool>,
-    resizable: Cell<bool>,
-    fullscreen: RefCell<Option<::MonitorId>>,
-    always_on_top: Cell<bool>,
-
     /// The current window state.
-    window_state: Arc<Mutex<events_loop::WindowState>>,
-
-    window_icon: Cell<Option<WinIcon>>,
-    taskbar_icon: Cell<Option<WinIcon>>,
+    window_state: Arc<Mutex<WindowState>>,
 
     // The events loop proxy.
     events_loop_proxy: events_loop::EventsLoopProxy,
 }
 
-unsafe impl Send for Window {}
-unsafe impl Sync for Window {}
-
 // https://blogs.msdn.microsoft.com/oldnewthing/20131017-00/?p=2903
 // The idea here is that we use the Adjust­Window­Rect­Ex function to calculate how much additional
 // non-client area gets added due to the styles we passed. To make the math simple,
@@ -280,32 +272,25 @@ impl Window {
 
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
-        if resizable == self.resizable.get() {
-            return;
-        }
-        if self.fullscreen.borrow().is_some() {
+        let mut window_state = self.window_state.lock().unwrap();
+        if mem::replace(&mut window_state.resizable, resizable) != resizable {
             // If we're in fullscreen, update stored configuration but don't apply anything.
-            self.resizable.replace(resizable);
-            return;
-        }
+            if window_state.fullscreen.is_none() {
+                let mut style = unsafe {
+                    winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE)
+                };
 
-        let mut style = unsafe {
-            winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE)
-        };
-        if resizable {
-            style |= winuser::WS_SIZEBOX as LONG;
-        } else {
-            style &= !winuser::WS_SIZEBOX as LONG;
-        }
+                if resizable {
+                    style |= WS_RESIZABLE as LONG;
+                } else {
+                    style &= !WS_RESIZABLE as LONG;
+                }
 
-        unsafe {
-            winuser::SetWindowLongW(
-                self.window.0,
-                winuser::GWL_STYLE,
-                style as _,
-            );
-        };
-        self.resizable.replace(resizable);
+                unsafe {
+                    winuser::SetWindowLongW(self.window.0, winuser::GWL_STYLE, style as _);
+                };
+            }
+        }
     }
 
     /// Returns the `hwnd` of this window.
@@ -388,15 +373,12 @@ impl Window {
     #[inline]
     pub fn grab_cursor(&self, grab: bool) -> Result<(), String> {
         let currently_grabbed = unsafe { self.cursor_is_grabbed() }?;
-        let window_state = Arc::clone(&self.window_state);
-        {
-            let window_state_lock = window_state.lock().unwrap();
-            if currently_grabbed == grab
-            && grab == window_state_lock.cursor_grabbed {
-                return Ok(());
-            }
+        let window_state_lock = self.window_state.lock().unwrap();
+        if currently_grabbed == grab && grab == window_state_lock.cursor_grabbed {
+            return Ok(());
         }
         let window = self.window.clone();
+        let window_state = Arc::clone(&self.window_state);
         let (tx, rx) = channel();
         self.events_loop_proxy.execute_in_thread(move |_| {
             let result = unsafe { Self::grab_cursor_inner(&window, grab) };
@@ -405,6 +387,7 @@ impl Window {
             }
             let _ = tx.send(result);
         });
+        drop(window_state_lock);
         rx.recv().unwrap()
     }
 
@@ -418,24 +401,23 @@ impl Window {
 
     #[inline]
     pub fn hide_cursor(&self, hide: bool) {
-        let window_state = Arc::clone(&self.window_state);
-        {
-            let window_state_lock = window_state.lock().unwrap();
-            // We don't want to increment/decrement the display count more than once!
-            if hide == window_state_lock.cursor_hidden { return; }
-        }
+        let window_state_lock = self.window_state.lock().unwrap();
+        // We don't want to increment/decrement the display count more than once!
+        if hide == window_state_lock.cursor_hidden { return; }
         let (tx, rx) = channel();
+        let window_state = Arc::clone(&self.window_state);
         self.events_loop_proxy.execute_in_thread(move |_| {
             unsafe { Self::hide_cursor_inner(hide) };
             window_state.lock().unwrap().cursor_hidden = hide;
             let _ = tx.send(());
         });
+        drop(window_state_lock);
         rx.recv().unwrap()
     }
 
     #[inline]
     pub fn get_hidpi_factor(&self) -> f64 {
-        get_window_scale_factor(self.window.0, self.window.1)
+        self.window_state.lock().unwrap().dpi_factor
     }
 
     fn set_cursor_position_physical(&self, x: i32, y: i32) -> Result<(), String> {
@@ -465,9 +447,12 @@ impl Window {
 
     #[inline]
     pub fn set_maximized(&self, maximized: bool) {
-        self.maximized.replace(maximized);
+        let mut window_state = self.window_state.lock().unwrap();
+        window_state.maximized = true;
         // We only maximize if we're not in fullscreen.
-        if self.fullscreen.borrow().is_some() { return; }
+        if window_state.fullscreen.is_none() {
+            return;
+        }
 
         let window = self.window.clone();
         unsafe {
@@ -485,12 +470,10 @@ impl Window {
         }
     }
 
-    unsafe fn set_fullscreen_style(&self) -> (LONG, LONG) {
-        let mut window_state = self.window_state.lock().unwrap();
-
-        if self.fullscreen.borrow().is_none() || window_state.saved_window_info.is_none() {
+    unsafe fn set_fullscreen_style(&self, window_state: &mut WindowState) -> (LONG, LONG) {
+        if window_state.fullscreen.is_none() || window_state.saved_window_info.is_none() {
             let rect = util::get_window_rect(self.window.0).expect("`GetWindowRect` failed");
-            let dpi_factor = Some(self.get_hidpi_factor());
+            let dpi_factor = Some(window_state.dpi_factor);
             window_state.saved_window_info = Some(events_loop::SavedWindowInfo {
                 style: winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE),
                 ex_style: winuser::GetWindowLongW(self.window.0, winuser::GWL_EXSTYLE),
@@ -504,16 +487,14 @@ impl Window {
         let mut placement: winuser::WINDOWPLACEMENT = mem::zeroed();
         placement.length = mem::size_of::<winuser::WINDOWPLACEMENT>() as u32;
         winuser::GetWindowPlacement(self.window.0, &mut placement);
-        self.maximized.replace(placement.showCmd == (winuser::SW_SHOWMAXIMIZED as u32));
+        window_state.maximized = placement.showCmd == (winuser::SW_SHOWMAXIMIZED as u32);
         let saved_window_info = window_state.saved_window_info.as_ref().unwrap();
 
         (saved_window_info.style, saved_window_info.ex_style)
     }
 
-    unsafe fn restore_saved_window(&self) {
+    unsafe fn restore_saved_window(&self, window_state_lock: &mut WindowState) {
         let (rect, mut style, ex_style) = {
-            let mut window_state_lock = self.window_state.lock().unwrap();
-
             // 'saved_window_info' can be None if the window has never been
             // in fullscreen mode before this method gets called.
             if window_state_lock.saved_window_info.is_none() {
@@ -534,8 +515,8 @@ impl Window {
         let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
-        let maximized = self.maximized.get();
-        let resizable = self.resizable.get();
+        let resizable = window_state_lock.resizable;
+        let maximized = window_state_lock.maximized;
 
         // We're restoring the window to its size and position from before being fullscreened.
         // `ShowWindow` resizes the window, so it must be called from the main thread.
@@ -543,9 +524,9 @@ impl Window {
             let _ = Self::grab_cursor_inner(&window, false);
 
             if resizable {
-                style |= winuser::WS_SIZEBOX as LONG;
+                style |= WS_RESIZABLE as LONG;
             } else {
-                style &= !winuser::WS_SIZEBOX as LONG;
+                style &= !WS_RESIZABLE as LONG;
             }
             winuser::SetWindowLongW(window.0, winuser::GWL_STYLE, style);
             winuser::SetWindowLongW(window.0, winuser::GWL_EXSTYLE, ex_style);
@@ -582,6 +563,7 @@ impl Window {
 
     #[inline]
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
+        let mut window_state_lock = self.window_state.lock().unwrap();
         unsafe {
             match &monitor {
                 &Some(RootMonitorId { ref inner }) => {
@@ -590,8 +572,7 @@ impl Window {
                     let window = self.window.clone();
                     let window_state = Arc::clone(&self.window_state);
 
-                    let (style, ex_style) = self.set_fullscreen_style();
-
+                    let (style, ex_style) = self.set_fullscreen_style(&mut window_state_lock);
                     self.events_loop_proxy.execute_in_thread(move |_| {
                         let _ = Self::grab_cursor_inner(&window, false);
 
@@ -631,27 +612,23 @@ impl Window {
                     });
                 }
                 &None => {
-                    self.restore_saved_window();
+                    self.restore_saved_window(&mut window_state_lock);
                 }
             }
         }
 
-        self.fullscreen.replace(monitor);
+        window_state_lock.fullscreen = monitor;
     }
 
     #[inline]
     pub fn set_decorations(&self, decorations: bool) {
-        if self.decorations.get() == decorations {
-            return;
-        }
-
+        let mut window_state = self.window_state.lock().unwrap();
+        if mem::replace(&mut window_state.decorations, decorations) != decorations {
         let style_flags = (winuser::WS_CAPTION | winuser::WS_THICKFRAME) as LONG;
         let ex_style_flags = (winuser::WS_EX_WINDOWEDGE) as LONG;
 
-        // if we are in fullscreen mode, we only change the saved window info
-        if self.fullscreen.borrow().is_some() {
-            {
-                let mut window_state = self.window_state.lock().unwrap();
+            // if we are in fullscreen mode, we only change the saved window info
+            if window_state.fullscreen.is_some() {
                 let saved = window_state.saved_window_info.as_mut().unwrap();
 
                 unsafe {
@@ -674,81 +651,73 @@ impl Window {
                         saved.ex_style as _,
                     );
                 }
-            }
-
-            self.decorations.replace(decorations);
-            return;
-        }
-
-        unsafe {
-            let mut rect: RECT = mem::zeroed();
-            winuser::GetWindowRect(self.window.0, &mut rect);
-
-            let mut style = winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE);
-            let mut ex_style = winuser::GetWindowLongW(self.window.0, winuser::GWL_EXSTYLE);
-            unjust_window_rect(&mut rect, style as _, ex_style as _);
-
-            if decorations {
-                style = style | style_flags;
-                ex_style = ex_style | ex_style_flags;
             } else {
-                style = style & !style_flags;
-                ex_style = ex_style & !ex_style_flags;
+                unsafe {
+                    let mut rect: RECT = mem::zeroed();
+                    winuser::GetWindowRect(self.window.0, &mut rect);
+
+                    let mut style = winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE);
+                    let mut ex_style = winuser::GetWindowLongW(self.window.0, winuser::GWL_EXSTYLE);
+                    unjust_window_rect(&mut rect, style as _, ex_style as _);
+
+                    if decorations {
+                        style = style | style_flags;
+                        ex_style = ex_style | ex_style_flags;
+                    } else {
+                        style = style & !style_flags;
+                        ex_style = ex_style & !ex_style_flags;
+                    }
+
+                    let window = self.window.clone();
+
+                    self.events_loop_proxy.execute_in_thread(move |_| {
+                        winuser::SetWindowLongW(window.0, winuser::GWL_STYLE, style);
+                        winuser::SetWindowLongW(window.0, winuser::GWL_EXSTYLE, ex_style);
+                        winuser::AdjustWindowRectEx(&mut rect, style as _, 0, ex_style as _);
+
+                        winuser::SetWindowPos(
+                            window.0,
+                            ptr::null_mut(),
+                            rect.left,
+                            rect.top,
+                            rect.right - rect.left,
+                            rect.bottom - rect.top,
+                            winuser::SWP_ASYNCWINDOWPOS
+                            | winuser::SWP_NOZORDER
+                            | winuser::SWP_NOACTIVATE
+                            | winuser::SWP_FRAMECHANGED,
+                        );
+                    });
+                }
             }
-
-            let window = self.window.clone();
-
-            self.events_loop_proxy.execute_in_thread(move |_| {
-                winuser::SetWindowLongW(window.0, winuser::GWL_STYLE, style);
-                winuser::SetWindowLongW(window.0, winuser::GWL_EXSTYLE, ex_style);
-                winuser::AdjustWindowRectEx(&mut rect, style as _, 0, ex_style as _);
-
-                winuser::SetWindowPos(
-                    window.0,
-                    ptr::null_mut(),
-                    rect.left,
-                    rect.top,
-                    rect.right - rect.left,
-                    rect.bottom - rect.top,
-                    winuser::SWP_ASYNCWINDOWPOS
-                    | winuser::SWP_NOZORDER
-                    | winuser::SWP_NOACTIVATE
-                    | winuser::SWP_FRAMECHANGED,
-                );
-            });
         }
-
-        self.decorations.replace(decorations);
     }
 
     #[inline]
     pub fn set_always_on_top(&self, always_on_top: bool) {
-        if self.always_on_top.get() == always_on_top {
-            return;
+        let mut window_state = self.window_state.lock().unwrap();
+        if mem::replace(&mut window_state.always_on_top, always_on_top) != always_on_top {
+            let window = self.window.clone();
+            self.events_loop_proxy.execute_in_thread(move |_| {
+                let insert_after = if always_on_top {
+                    winuser::HWND_TOPMOST
+                } else {
+                    winuser::HWND_NOTOPMOST
+                };
+                unsafe {
+                    winuser::SetWindowPos(
+                        window.0,
+                        insert_after,
+                        0,
+                        0,
+                        0,
+                        0,
+                        winuser::SWP_ASYNCWINDOWPOS | winuser::SWP_NOMOVE | winuser::SWP_NOSIZE,
+                    );
+                    winuser::UpdateWindow(window.0);
+                }
+            });
         }
-
-        let window = self.window.clone();
-        self.events_loop_proxy.execute_in_thread(move |_| {
-            let insert_after = if always_on_top {
-                winuser::HWND_TOPMOST
-            } else {
-                winuser::HWND_NOTOPMOST
-            };
-            unsafe {
-                winuser::SetWindowPos(
-                    window.0,
-                    insert_after,
-                    0,
-                    0,
-                    0,
-                    0,
-                    winuser::SWP_ASYNCWINDOWPOS | winuser::SWP_NOMOVE | winuser::SWP_NOSIZE,
-                );
-                winuser::UpdateWindow(window.0);
-            }
-        });
-
-        self.always_on_top.replace(always_on_top);
     }
 
     #[inline]
@@ -768,7 +737,7 @@ impl Window {
         } else {
             icon::unset_for_window(self.window.0, IconType::Small);
         }
-        self.window_icon.replace(window_icon);
+        self.window_state.lock().unwrap().window_icon = window_icon;
     }
 
     #[inline]
@@ -781,7 +750,7 @@ impl Window {
         } else {
             icon::unset_for_window(self.window.0, IconType::Big);
         }
-        self.taskbar_icon.replace(taskbar_icon);
+        self.window_state.lock().unwrap().taskbar_icon = taskbar_icon;
     }
 
     #[inline]
@@ -804,17 +773,27 @@ impl Drop for Window {
 /// A simple non-owning wrapper around a window.
 #[doc(hidden)]
 #[derive(Clone)]
-pub struct WindowWrapper(HWND, HDC);
+pub struct WindowWrapper(HWND);
 
-// Send is not implemented for HWND and HDC, we have to wrap it and implement it manually.
+// Send and Sync are not implemented for HWND and HDC, we have to wrap it and implement them manually.
 // For more info see:
 // https://github.com/retep998/winapi-rs/issues/360
 // https://github.com/retep998/winapi-rs/issues/396
+unsafe impl Sync for WindowWrapper {}
 unsafe impl Send for WindowWrapper {}
 
-pub unsafe fn adjust_size(physical_size: PhysicalSize, style: DWORD, ex_style: DWORD) -> (LONG, LONG) {
+pub unsafe fn adjust_size(
+    physical_size: PhysicalSize,
+    style: DWORD,
+    ex_style: DWORD,
+) -> (LONG, LONG) {
     let (width, height): (u32, u32) = physical_size.into();
-    let mut rect = RECT { left: 0, right: width as LONG, top: 0, bottom: height as LONG };
+    let mut rect = RECT {
+        left: 0,
+        right: width as LONG,
+        top: 0,
+        bottom: height as LONG,
+    };
     winuser::AdjustWindowRectEx(&mut rect, style, 0, ex_style);
     (rect.right - rect.left, rect.bottom - rect.top)
 }
@@ -858,9 +837,38 @@ unsafe fn init(
     // registering the window class
     let class_name = register_window_class(&window_icon, &taskbar_icon);
 
-    let (width, height) = attributes.dimensions
-        .map(Into::into)
-        .unwrap_or((1024, 768));
+    let guessed_dpi_factor = {
+        let monitors = get_available_monitors();
+        let dpi_factor = if !monitors.is_empty() {
+            let mut dpi_factor = Some(monitors[0].get_hidpi_factor());
+            for monitor in &monitors {
+                if Some(monitor.get_hidpi_factor()) != dpi_factor {
+                    dpi_factor = None;
+                }
+            }
+            dpi_factor
+        } else {
+            return Err(CreationError::OsError(format!("No monitors were detected.")));
+        };
+        dpi_factor.unwrap_or_else(|| {
+            util::get_cursor_pos()
+                .and_then(|cursor_pos| {
+                    let mut dpi_factor = None;
+                    for monitor in &monitors {
+                        if monitor.contains_point(&cursor_pos) {
+                            dpi_factor = Some(monitor.get_hidpi_factor());
+                            break;
+                        }
+                    }
+                    dpi_factor
+                })
+                .unwrap_or(1.0)
+        })
+    };
+    info!("Guessed window DPI factor: {}", guessed_dpi_factor);
+
+    let dimensions = attributes.dimensions.unwrap_or_else(|| (1024, 768).into());
+    let (width, height): (u32, u32) = dimensions.to_physical(guessed_dpi_factor).into();
     // building a RECT object with coordinates
     let mut rect = RECT {
         left: 0,
@@ -899,11 +907,11 @@ unsafe fn init(
     let real_window = {
         let (adjusted_width, adjusted_height) = if attributes.dimensions.is_some() {
             let min_dimensions = attributes.min_dimensions
-                .map(|logical_size| PhysicalSize::from_logical(logical_size, 1.0))
+                .map(|logical_size| PhysicalSize::from_logical(logical_size, guessed_dpi_factor))
                 .map(|physical_size| adjust_size(physical_size, style, ex_style))
                 .unwrap_or((0, 0));
             let max_dimensions = attributes.max_dimensions
-                .map(|logical_size| PhysicalSize::from_logical(logical_size, 1.0))
+                .map(|logical_size| PhysicalSize::from_logical(logical_size, guessed_dpi_factor))
                 .map(|physical_size| adjust_size(physical_size, style, ex_style))
                 .unwrap_or((c_int::max_value(), c_int::max_value()));
             (
@@ -921,7 +929,7 @@ unsafe fn init(
         };
 
         if !attributes.resizable {
-            style &= !winuser::WS_SIZEBOX;
+            style &= !WS_RESIZABLE;
         }
 
         if pl_attribs.parent.is_some() {
@@ -946,13 +954,7 @@ unsafe fn init(
                                               format!("{}", io::Error::last_os_error()))));
         }
 
-        let hdc = winuser::GetDC(handle);
-        if hdc.is_null() {
-            return Err(CreationError::OsError(format!("GetDC function failed: {}",
-                                              format!("{}", io::Error::last_os_error()))));
-        }
-
-        WindowWrapper(handle, hdc)
+        WindowWrapper(handle)
     };
 
     // Set up raw input
@@ -966,9 +968,10 @@ unsafe fn init(
         }
     }
 
-    let dpi = get_window_dpi(real_window.0, real_window.1);
+    let dpi = get_hwnd_dpi(real_window.0);
     let dpi_factor = dpi_to_scale_factor(dpi);
-    if dpi != BASE_DPI {
+    if dpi_factor != guessed_dpi_factor {
+        let (width, height): (u32, u32) = dimensions.into();
         let mut packed_dimensions = 0;
         // MAKELPARAM isn't provided by winapi yet.
         let ptr = &mut packed_dimensions as *mut LPARAM as *mut WORD;
@@ -996,6 +999,13 @@ unsafe fn init(
             mouse_in_window: false,
             saved_window_info: None,
             dpi_factor,
+            fullscreen: attributes.fullscreen.clone(),
+            window_icon,
+            taskbar_icon,
+            decorations: attributes.decorations,
+            maximized: attributes.maximized,
+            resizable: attributes.resizable,
+            always_on_top: attributes.always_on_top,
         };
         // Creating a mutex to track the current window state
         Arc::new(Mutex::new(window_state))
@@ -1015,14 +1025,7 @@ unsafe fn init(
 
     let win = Window {
         window: real_window,
-        window_state: window_state,
-        decorations: Cell::new(attributes.decorations),
-        maximized: Cell::new(attributes.maximized.clone()),
-        resizable: Cell::new(attributes.resizable.clone()),
-        fullscreen: RefCell::new(attributes.fullscreen.clone()),
-        always_on_top: Cell::new(attributes.always_on_top),
-        window_icon: Cell::new(window_icon),
-        taskbar_icon: Cell::new(taskbar_icon),
+        window_state,
         events_loop_proxy,
     };
 
@@ -1079,7 +1082,6 @@ unsafe fn register_window_class(
     class_name
 }
 
-
 struct ComInitialized(*mut ());
 impl Drop for ComInitialized {
     fn drop(&mut self) {

src/window.rs

@@ -304,6 +304,10 @@ impl Window {
     ///
     /// See the [`dpi`](dpi/index.html) module for more information.
     ///
+    /// Note that this value can change depending on user action (for example if the window is
+    /// moved to another screen); as such, tracking `WindowEvent::HiDpiFactorChanged` events is
+    /// the most robust way to track the DPI you need to use to draw.
+    ///
     /// ## Platform-specific
     ///
     /// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.