Update cocoa and core-graphics (#608)

* Update cocoa and core-graphics

* Release winit 0.17.0

* Updated date / README version

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Unreleased
 
+# 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.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.16.2"
+version = "0.17.0"
 authors = ["The winit contributors, Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
@@ -26,13 +26,13 @@ image = { version = "0.19", optional = true }
 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"
@@ -53,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"
+[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.17.5"
 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 (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. 
+//! *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.
 //!
 
@@ -104,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.
@@ -166,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;

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/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,8 +26,9 @@ use {
     WindowAttributes,
 };
 use platform::platform::{Cursor, PlatformSpecificWindowBuilderAttributes, WindowId};
-use platform::platform::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;
@@ -40,25 +41,13 @@ 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,
@@ -283,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 |= WS_RESIZABLE as LONG;
-        } else {
-            style &= !WS_RESIZABLE 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.
@@ -391,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) };
@@ -408,6 +387,7 @@ impl Window {
             }
             let _ = tx.send(result);
         });
+        drop(window_state_lock);
         rx.recv().unwrap()
     }
 
@@ -421,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> {
@@ -468,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 {
@@ -488,10 +470,8 @@ 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());
             window_state.saved_window_info = Some(events_loop::SavedWindowInfo {
@@ -507,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() {
@@ -537,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.
@@ -585,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 }) => {
@@ -593,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);
 
@@ -634,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 {
@@ -677,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]
@@ -771,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]
@@ -784,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]
@@ -807,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)
 }
@@ -978,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
@@ -998,7 +968,7 @@ 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_factor != guessed_dpi_factor {
         let (width, height): (u32, u32) = dimensions.into();
@@ -1029,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))
@@ -1048,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,
     };
 
@@ -1112,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.