version 0.17.2 (#630 )

* version 0.17.2 * Update release date
Add key repetition for the wayland backend (#628 )
2026-06-26 22:53:15 -04:00 · 2018-08-19 18:27:57 -04:00 · 2018-08-19 17:17:40 -04:00 · 2018-08-15 19:42:57 -04:00 · 2018-08-07 14:24:43 -04:00 · 2018-08-05 02:24:49 -04:00
35 changed files with 742 additions and 520 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 Cargo.lock
 target/
 rls/
+.vscode/
 *~
 #*#
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,40 @@
 # Unreleased

+# Version 0.17.2 (2018-08-19)
+
+- On macOS, fix `<C-Tab>` so applications receive the event.
+- On macOS, fix `<Cmd-{key}>` so applications receive the event.
+- On Wayland, key press events will now be repeated.
+
+# 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`.
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.16.0"
+version = "0.17.2"
 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.3.0"
+x11-dl = "2.18.3"
+parking_lot = "0.6"
 percent-encoding = "1.0"
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@

 ```toml
 [dependencies]
-winit = "0.16"
+winit = "0.17"
 ```

 ## [Documentation](https://docs.rs/winit)
--- a/src/dpi.rs
+++ b/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.
--- a/src/lib.rs
+++ b/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()`
--- a/src/os/ios.rs
+++ b/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.
--- a/src/os/unix.rs
+++ b/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;
--- a/src/platform/ios/ffi.rs
+++ b/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))
-    }
-}
--- a/src/platform/ios/mod.rs
+++ b/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 {
--- a/src/platform/linux/dlopen.rs
+++ b/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};
--- a/src/platform/linux/mod.rs
+++ b/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};
--- a/src/platform/linux/wayland/event_loop.rs
+++ b/src/platform/linux/wayland/event_loop.rs
@@ -1,20 +1,21 @@
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::fmt;
-use std::sync::{Arc, Mutex, Weak};
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, Weak};

 use {ControlFlow, EventsLoopClosed, PhysicalPosition, PhysicalSize};

-use super::WindowId;
 use super::window::WindowStore;
+use super::WindowId;

-use sctk::Environment;
 use sctk::output::OutputMgr;
-use sctk::reexports::client::{Display, EventQueue, GlobalEvent, Proxy, ConnectError};
 use sctk::reexports::client::commons::Implementation;
-use sctk::reexports::client::protocol::{wl_keyboard, wl_output, wl_pointer, wl_registry, wl_seat,
-                                        wl_touch};
+use sctk::reexports::client::protocol::{
+    wl_keyboard, wl_output, wl_pointer, wl_registry, wl_seat, wl_touch,
+};
+use sctk::reexports::client::{ConnectError, Display, EventQueue, GlobalEvent, Proxy};
+use sctk::Environment;

 use sctk::reexports::client::protocol::wl_display::RequestsTrait as DisplayRequests;

@@ -104,6 +105,8 @@ impl EventsLoop {
    pub fn new() -> Result<EventsLoop, ConnectError> {
        let (display, mut event_queue) = Display::connect_to_env()?;

+        let display = Arc::new(display);
+        let pending_wakeup = Arc::new(AtomicBool::new(false));
        let sink = Arc::new(Mutex::new(EventsLoopSink::new()));
        let store = Arc::new(Mutex::new(WindowStore::new()));
        let seats = Arc::new(Mutex::new(Vec::new()));
@@ -115,18 +118,22 @@ impl EventsLoop {
                sink: sink.clone(),
                store: store.clone(),
                seats: seats.clone(),
+                events_loop_proxy: EventsLoopProxy {
+                    display: Arc::downgrade(&display),
+                    pending_wakeup: Arc::downgrade(&pending_wakeup),
+                },
            },
        ).unwrap();

        Ok(EventsLoop {
-            display: Arc::new(display),
+            display,
            evq: RefCell::new(event_queue),
-            sink: sink,
-            pending_wakeup: Arc::new(AtomicBool::new(false)),
-            store: store,
-            env: env,
+            sink,
+            pending_wakeup,
+            store,
+            env,
            cleanup_needed: Arc::new(Mutex::new(false)),
-            seats: seats,
+            seats,
        })
    }

@@ -266,6 +273,7 @@ struct SeatManager {
    sink: Arc<Mutex<EventsLoopSink>>,
    store: Arc<Mutex<WindowStore>>,
    seats: Arc<Mutex<Vec<(u32, Proxy<wl_seat::WlSeat>)>>>,
+    events_loop_proxy: EventsLoopProxy,
 }

 impl Implementation<Proxy<wl_registry::WlRegistry>, GlobalEvent> for SeatManager {
@@ -289,6 +297,7 @@ impl Implementation<Proxy<wl_registry::WlRegistry>, GlobalEvent> for SeatManager
                        pointer: None,
                        keyboard: None,
                        touch: None,
+                        events_loop_proxy: self.events_loop_proxy.clone(),
                    });
                self.store.lock().unwrap().new_seat(&seat);
                self.seats.lock().unwrap().push((id, seat));
@@ -313,6 +322,7 @@ struct SeatData {
    pointer: Option<Proxy<wl_pointer::WlPointer>>,
    keyboard: Option<Proxy<wl_keyboard::WlKeyboard>>,
    touch: Option<Proxy<wl_touch::WlTouch>>,
+    events_loop_proxy: EventsLoopProxy,
 }

 impl Implementation<Proxy<wl_seat::WlSeat>, wl_seat::Event> for SeatData {
@@ -343,6 +353,7 @@ impl Implementation<Proxy<wl_seat::WlSeat>, wl_seat::Event> for SeatData {
                    self.keyboard = Some(super::keyboard::init_keyboard(
                        seat.get_keyboard().unwrap(),
                        self.sink.clone(),
+                        self.events_loop_proxy.clone(),
                    ))
                }
                // destroy keyboard if applicable
--- a/src/platform/linux/wayland/keyboard.rs
+++ b/src/platform/linux/wayland/keyboard.rs
@@ -1,77 +1,110 @@
 use std::sync::{Arc, Mutex};

-use {ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
-
-use super::{make_wid, DeviceId, EventsLoopSink};
-use sctk::keyboard::{self, map_keyboard_auto, Event as KbEvent};
-use sctk::reexports::client::{NewProxy, Proxy};
+use super::{make_wid, DeviceId, EventsLoopProxy, EventsLoopSink};
+use sctk::keyboard::{
+    self, map_keyboard_auto_with_repeat, Event as KbEvent, KeyRepeatEvent, KeyRepeatKind,
+};
 use sctk::reexports::client::protocol::wl_keyboard;
+use sctk::reexports::client::{NewProxy, Proxy};
+use {ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};

 pub fn init_keyboard(
    keyboard: NewProxy<wl_keyboard::WlKeyboard>,
    sink: Arc<Mutex<EventsLoopSink>>,
+    events_loop_proxy: EventsLoopProxy,
 ) -> Proxy<wl_keyboard::WlKeyboard> {
-    // { variables to be captured by the closure
-    let mut target = None;
+    // { variables to be captured by the closures
+    let target = Arc::new(Mutex::new(None));
    let my_sink = sink.clone();
+    let repeat_sink = sink.clone();
+    let repeat_target = target.clone();
    // }
-    let ret = map_keyboard_auto(keyboard, move |evt: KbEvent, _| match evt {
-        KbEvent::Enter { surface, .. } => {
-            let wid = make_wid(&surface);
-            my_sink
-                .lock()
-                .unwrap()
-                .send_event(WindowEvent::Focused(true), wid);
-            target = Some(wid);
-        }
-        KbEvent::Leave { surface, .. } => {
-            let wid = make_wid(&surface);
-            my_sink
-                .lock()
-                .unwrap()
-                .send_event(WindowEvent::Focused(false), wid);
-            target = None;
-        }
-        KbEvent::Key {
-            modifiers,
-            rawkey,
-            keysym,
-            state,
-            utf8,
-            ..
-        } => {
-            if let Some(wid) = target {
-                let state = match state {
-                    wl_keyboard::KeyState::Pressed => ElementState::Pressed,
-                    wl_keyboard::KeyState::Released => ElementState::Released,
-                };
-                let vkcode = key_to_vkey(rawkey, keysym);
-                let mut guard = my_sink.lock().unwrap();
+    let ret = map_keyboard_auto_with_repeat(
+        keyboard,
+        KeyRepeatKind::System,
+        move |evt: KbEvent, _| match evt {
+            KbEvent::Enter { surface, .. } => {
+                let wid = make_wid(&surface);
+                my_sink
+                    .lock()
+                    .unwrap()
+                    .send_event(WindowEvent::Focused(true), wid);
+                *target.lock().unwrap() = Some(wid);
+            }
+            KbEvent::Leave { surface, .. } => {
+                let wid = make_wid(&surface);
+                my_sink
+                    .lock()
+                    .unwrap()
+                    .send_event(WindowEvent::Focused(false), wid);
+                *target.lock().unwrap() = None;
+            }
+            KbEvent::Key {
+                modifiers,
+                rawkey,
+                keysym,
+                state,
+                utf8,
+                ..
+            } => {
+                if let Some(wid) = *target.lock().unwrap() {
+                    let state = match state {
+                        wl_keyboard::KeyState::Pressed => ElementState::Pressed,
+                        wl_keyboard::KeyState::Released => ElementState::Released,
+                    };
+                    let vkcode = key_to_vkey(rawkey, keysym);
+                    let mut guard = my_sink.lock().unwrap();
+                    guard.send_event(
+                        WindowEvent::KeyboardInput {
+                            device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
+                            input: KeyboardInput {
+                                state: state,
+                                scancode: rawkey,
+                                virtual_keycode: vkcode,
+                                modifiers: modifiers.into(),
+                            },
+                        },
+                        wid,
+                    );
+                    // send char event only on key press, not release
+                    if let ElementState::Released = state {
+                        return;
+                    }
+                    if let Some(txt) = utf8 {
+                        for chr in txt.chars() {
+                            guard.send_event(WindowEvent::ReceivedCharacter(chr), wid);
+                        }
+                    }
+                }
+            }
+            KbEvent::RepeatInfo { .. } => { /* Handled by smithay client toolkit */ }
+        },
+        move |repeat_event: KeyRepeatEvent, _| {
+            if let Some(wid) = *repeat_target.lock().unwrap() {
+                let state = ElementState::Pressed;
+                let vkcode = key_to_vkey(repeat_event.rawkey, repeat_event.keysym);
+                let mut guard = repeat_sink.lock().unwrap();
                guard.send_event(
                    WindowEvent::KeyboardInput {
                        device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
                        input: KeyboardInput {
                            state: state,
-                            scancode: rawkey,
+                            scancode: repeat_event.rawkey,
                            virtual_keycode: vkcode,
-                            modifiers: modifiers.into(),
+                            modifiers: repeat_event.modifiers.into(),
                        },
                    },
                    wid,
                );
-                // send char event only on key press, not release
-                if let ElementState::Released = state {
-                    return;
-                }
-                if let Some(txt) = utf8 {
+                if let Some(txt) = repeat_event.utf8 {
                    for chr in txt.chars() {
                        guard.send_event(WindowEvent::ReceivedCharacter(chr), wid);
                    }
                }
+                events_loop_proxy.wakeup().unwrap();
            }
-        }
-        KbEvent::RepeatInfo { .. } => { /* TODO: handle repeat info */ }
-    });
+        },
+    );

    match ret {
        Ok(keyboard) => keyboard,
--- a/src/platform/linux/wayland/mod.rs
+++ b/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};
--- a/src/platform/linux/x11/mod.rs
+++ b/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
--- a/src/platform/linux/x11/monitor.rs
+++ b/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)
--- a/src/platform/linux/x11/util/format.rs
+++ b/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; }
--- a/src/platform/linux/x11/util/geometry.rs
+++ b/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
    }
--- a/src/platform/linux/x11/util/input.rs
+++ b/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,
--- a/src/platform/linux/x11/util/randr.rs
+++ b/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;
    }

--- a/src/platform/linux/x11/window.rs
+++ b/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;
        }

--- a/src/platform/macos/events_loop.rs
+++ b/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");
            }
        }
@@ -315,6 +315,27 @@ impl EventsLoop {
            });

        match event_type {
+            // https://github.com/glfw/glfw/blob/50eccd298a2bbc272b4977bd162d3e4b55f15394/src/cocoa_window.m#L881
+            appkit::NSKeyUp  => {
+                if let Some(key_window) = maybe_key_window() {
+                    if event_mods(ns_event).logo {
+                        let _: () = msg_send![*key_window.window, sendEvent:ns_event];
+                    }
+                }
+                None
+            },
+            // similar to above, but for `<Cmd-.>`, the keyDown is suppressed instead of the
+            // KeyUp, and the above trick does not appear to work.
+            appkit::NSKeyDown => {
+                let modifiers = event_mods(ns_event);
+                let keycode = NSEvent::keyCode(ns_event);
+                if modifiers.logo && keycode == 47 {
+                    modifier_event(ns_event, NSEventModifierFlags::NSCommandKeyMask, false)
+                        .map(into_event)
+                } else {
+                    None
+                }
+            },
            appkit::NSFlagsChanged => {
                let mut events = std::collections::VecDeque::new();

@@ -674,11 +695,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);
--- a/src/platform/macos/ffi.rs
+++ b/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
--- a/src/platform/macos/util.rs
+++ b/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];
 }
--- a/src/platform/macos/view.rs
+++ b/src/platform/macos/view.rs
@@ -7,11 +7,11 @@ 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;
-use objc::runtime::{Class, Object, Protocol, Sel, BOOL};
+use objc::runtime::{Class, Object, Protocol, Sel, BOOL, YES};

 use {ElementState, Event, KeyboardInput, MouseButton, WindowEvent, WindowId};
 use platform::platform::events_loop::{DEVICE_ID, event_mods, Shared, to_virtual_key_code};
@@ -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(
@@ -122,6 +122,7 @@ lazy_static! {
        decl.add_method(sel!(mouseDragged:), mouse_dragged as extern fn(&Object, Sel, id));
        decl.add_method(sel!(rightMouseDragged:), right_mouse_dragged as extern fn(&Object, Sel, id));
        decl.add_method(sel!(otherMouseDragged:), other_mouse_dragged as extern fn(&Object, Sel, id));
+        decl.add_method(sel!(_wantsKeyDownForEvent:), wants_key_down_for_event as extern fn(&Object, Sel, id) -> BOOL);
        decl.add_ivar::<*mut c_void>("winitState");
        decl.add_ivar::<id>("markedText");
        let protocol = Protocol::get("NSTextInputClient").unwrap();
@@ -191,7 +192,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 +215,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 +266,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 +283,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 +401,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];
            }
        }
@@ -566,3 +567,8 @@ extern fn right_mouse_dragged(this: &Object, _sel: Sel, event: id) {
 extern fn other_mouse_dragged(this: &Object, _sel: Sel, event: id) {
    mouse_motion(this, event);
 }
+
+// https://github.com/chromium/chromium/blob/a86a8a6bcfa438fa3ac2eba6f02b3ad1f8e0756f/ui/views/cocoa/bridged_content_view.mm#L816
+extern fn wants_key_down_for_event(_this: &Object, _se: Sel, _event: id) -> BOOL {
+    YES
+}
--- a/src/platform/macos/window.rs
+++ b/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);
        }
    }

--- a/src/platform/mod.rs
+++ b/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");
--- a/src/platform/windows/dpi.rs
+++ b/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) })
 }
--- a/src/platform/windows/events_loop.rs
+++ b/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 {
--- a/src/platform/windows/icon.rs
+++ b/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> {
--- a/src/platform/windows/monitor.rs
+++ b/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())
--- a/src/platform/windows/util.rs
+++ b/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;
--- a/src/platform/windows/window.rs
+++ b/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 AdjustWindowRectEx 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) {
--- a/src/window.rs
+++ b/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.
Author	SHA1	Message	Date
Joe Moon	c8e339fe6d	version 0.17.2 (#630 ) * version 0.17.2 * Update release date	2018-08-19 18:27:57 -04:00
trimental	e4e53fe315	Add key repetition for the wayland backend (#628 ) * Add key repetition for the wayland backend * Upgrade smithay-client-toolkit to 0.3.0	2018-08-19 17:17:40 -04:00
Joe Moon	1c795c3f1c	625 macos modifiers (#629 ) * fix <C-Tab> * fix <CMD-{key}> * move the NSKeyUp special handling into the match statement * add special handling for `<Cmd-.>` * formatting * add return type to msg_send!	2018-08-15 19:42:57 -04:00
Francesca Frangipane	b2b740fed7	Windows: Fix fullscreen deadlock + release 0.17.1 (#622 ) * Windows: Fix fullscreen deadlock * Release winit 0.17.1	2018-08-07 14:24:43 -04:00
Azriel Hoh	09550397d7	Maintenance/620/fix x11 release mode compilation (#621 ) * Raised minimum version of `x11-dl`. This fixes a compilation error in release mode on X11. Issue #620 * Updated `CHANGELOG.md` about X11 release mode compilation issue.	2018-08-05 02:24:49 -04:00
Paul Rouget	a32f7f2ec5	Update cocoa and core-graphics (#608 ) * Update cocoa and core-graphics * Release winit 0.17.0 * Updated date / README version	2018-08-02 16:26:30 -04:00
Dennis Möhlmann	e8e9fa2418	fix assertion failed: validate_hidpi_factor(dpi_factor) (#607 ) (#618 ) * fix assertion failed: validate_hidpi_factor(dpi_factor) (#607) * added changelog entry	2018-08-02 13:03:15 -04:00
Felix Rabe	1a119bdfe9	Use consistent order inside #[cfg(any(...))] (#619 )	2018-08-01 15:22:14 -04:00
Andrew Hickman	21ff2e0ffc	Fix unsoundness on Windows (#601 ) * Fix unsoundness in windows backend * Synchronize window state properly * update changelog and add a comment to execute_in_thread * Formatting fixes and improve changelog message	2018-07-27 18:34:08 -04:00
Felix Rabe	df9b23c96a	Typo: retreiv... -> retriev... (#614 )	2018-07-27 14:59:53 -04:00
mtak-	4c117aa282	iOS: Fix the `longjmp`/`setjmp` ffi (#613 ) * iOS: Fix the `longjmp`/`setjmp` ffi. `jmp_buf` was the wrong size (too small) causing crashes on application launch, make longjmp return Never * remove extra parentheses around JBLEN, and add a changelog entry about the JmpBuf fix	2018-07-26 19:27:26 -04:00
Francesca Frangipane	88427262a6	macOS: Fix cursor hiding thread unsafety (#611 )	2018-07-26 17:14:16 -04:00
mtak-	72b24a9348	iOS Abstract Out the UIView type from winit (#609 ) * remove opengl code from winit * iOS: restrict EventsLoop to be created on the main thread iOS: Window can only be made once, make Drop on Window thread safe iOS: make DelegateState owned by Window, cleanup iOS: fixes from merge (class! macro) * update the changelog * Fixed nitpicks	2018-07-25 14:49:46 -04:00
Paul Rouget	01cb8e59e3	Fix key state on MacOS (#610 )	2018-07-25 13:36:33 -04:00
trimental	3910326709	Update wayland-client and client-toolkit (#602 )	2018-07-20 12:08:55 -04:00
Josh Groves	7ee46d80e6	Use class macro (#605 )	2018-07-19 12:02:33 -04:00
Victor Berger	0cb5450999	Clarify DPI docs to highlight WindowEvent::HiDpiFactorChanged (#598 ) * Clarify DPI docs to highlight WindowEvent::HiDpiFactorChanged * Address review of #598 * dpi docs: grammar corrections * The final nitpick	2018-07-16 10:44:29 -04:00
Iku Iwasa	8c78013257	Support NetBSD platform (#603 ) * Support NetBSD platform * CHANGELOG tweak + target ordering	2018-07-16 10:25:26 -04:00
mtak-	bd944898f0	set the UIViewController's view to the one that was just created (#595 ) * set the UIViewController's view to the one that was just created * capture the return value in a Unit to avoid SIGILL/SIGSEGV's. change whitespace to be more idiomatic of Obj-C * CHANGELOG entry	2018-07-13 15:10:12 -04:00
Bastien Orivel	c1ef1acfc0	Update parking_lot and bump version (#593 )	2018-07-07 17:21:53 -04:00
Francesca Frangipane	040d3f5d8b	Remove incorrect unreachable usage when guessing DPI factor (#592 )	2018-07-05 11:52:25 -04:00
Joshua Minter	ec393e4a90	Disable maximize button on non-resizable windows (#588 ) * Disabled maximize button When creating a non resizable window in win32. Also added example code to test. * Added to changelog * Added to documentation * Removed non_resizable test * Other suggested PR changes * Documentation changes * CHANGELOG nits	2018-07-03 20:15:19 -04:00
Francesca Frangipane	1703d0417a	Release winit 0.16.1 (#587 )	2018-07-02 20:14:38 -04:00
Francesca Frangipane	fad72c0441	X11: Fix compilation when c_char==c_uchar (#586 )	2018-07-02 11:05:25 -04:00
Francesca Frangipane	2f7321a076	X11+Windows: Guess initial DPI factor (#583 ) * X11: Guess initial DPI factor * Windows: Guess initial DPI factor	2018-07-01 11:01:46 -04:00
icefoxen	85ee422acd	Define "DPI" in docs. (#580 ) It makes my pedant reflexes tingle.	2018-06-28 14:05:56 -04:00