fix broken / missing raw-window-handle implementation on android (#1258)

* Add raw-window-handle support to Winit 0.19 and bump version

* Hopefully fix linux and ios builds

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,3 +2,4 @@
 - [ ] Added an entry to `CHANGELOG.md` if knowledge of this change could be valuable to users
 - [ ] Updated documentation to reflect any user-facing changes, including notes of platform-specific behavior
 - [ ] Created an example program if it would help users understand this functionality
+- [ ] Updated [feature matrix](https://github.com/rust-windowing/winit/blob/master/FEATURES.md), if new features were added or implemented

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "deps/apk-builder"]
 	path = deps/apk-builder
-	url = https://github.com/tomaka/android-rs-glue
+	url = https://github.com/rust-windowing/android-rs-glue

.travis.yml

@@ -19,12 +19,6 @@ matrix:
       addons:
         apt:
           packages: *i686_packages
-    - env: TARGET=i686-unknown-linux-gnu
-      os: linux
-      rust: 1.24.1
-      addons:
-        apt:
-          packages: *i686_packages
 
     # Linux 64bit
     - env: TARGET=x86_64-unknown-linux-gnu
@@ -33,9 +27,6 @@ matrix:
     - env: TARGET=x86_64-unknown-linux-gnu
       os: linux
       rust: stable
-    - env: TARGET=x86_64-unknown-linux-gnu
-      os: linux
-      rust: 1.24.1
 
     # macOS
     - env: TARGET=x86_64-apple-darwin
@@ -44,9 +35,6 @@ matrix:
     - env: TARGET=x86_64-apple-darwin
       os: osx
       rust: stable
-    - env: TARGET=x86_64-apple-darwin
-      os: osx
-      rust: 1.24.1
 
     # iOS
     - env: TARGET=x86_64-apple-ios
@@ -55,9 +43,6 @@ matrix:
     - env: TARGET=x86_64-apple-ios
       os: osx
       rust: stable
-    - env: TARGET=x86_64-apple-ios
-      os: osx
-      rust: 1.24.1
 
 install:
   - rustup self update

CHANGELOG.md

@@ -1,5 +1,72 @@
 # Unreleased
 
+# Version 0.19.5 (2019-11-04)
+
+- On Android, fix the missing `raw-window-handle` support
+
+# Version 0.19.4 (2019-10-16)
+
+- Add support for `raw-window-handle` 0.3.
+
+# Version 0.19.3 (2019-08-26)
+
+- Update parking_lot version.
+
+# Version 0.19.2 (2019-07-29)
+
+- On X11, fix sanity check which checks that a monitor's reported width and height (in millimeters) are non-zero when calculating the DPI factor.
+
+# Version 0.19.1 (2019-04-08)
+
+- On Wayland, added a `get_wayland_display` function to `EventsLoopExt`.
+- On Windows, fix `CursorMoved(0, 0)` getting dispatched on window focus.
+- On macOS, fix command key event left and right reverse.
+- On FreeBSD, NetBSD, and OpenBSD, fix build of X11 backend.
+- On Windows, fix icon not showing up in corner of window.
+- On X11, change DPI scaling factor behavior. First, winit tries to read it from "Xft.dpi" XResource, and uses DPI calculation from xrandr dimensions as fallback behavior.
+
+# Version 0.19.0 (2019-03-06)
+
+- On X11, we will use the faster `XRRGetScreenResourcesCurrent` function instead of `XRRGetScreenResources` when available.
+- On macOS, fix keycodes being incorrect when using a non-US keyboard layout.
+- On Wayland, fix `with_title()` not setting the windows title
+- On Wayland, add `set_wayland_theme()` to control client decoration color theme
+- Added serde serialization to `os::unix::XWindowType`.
+- **Breaking:** `image` crate upgraded to 0.21. This is exposed as part of the `icon_loading` API.
+- On X11, make event loop thread safe by replacing XNextEvent with select(2) and XCheckIfEvent
+- On Windows, fix malformed function pointer typecast that could invoke undefined behavior.
+- Refactored Windows state/flag-setting code.
+- On Windows, hiding the cursor no longer hides the cursor for all Winit windows - just the one `hide_cursor` was called on.
+- On Windows, cursor grabs used to get perpetually canceled when the grabbing window lost focus. Now, cursor grabs automatically get re-initialized when the window regains focus and the mouse moves over the client area.
+- On Windows, only vertical mouse wheel events were handled. Now, horizontal mouse wheel events are also handled.
+- On Windows, ignore the AltGr key when populating the `ModifersState` type.
+- On Linux, the numpad's add, subtract and divide keys are now mapped to the `Add`, `Subtract` and `Divide` virtual key codes
+- On macOS, the numpad's subtract key has been added to the `Subtract` mapping
+- On Wayland, the numpad's home, end, page up and page down keys are now mapped to the `Home`, `End`, `PageUp` and `PageDown` virtual key codes
+
+# Version 0.18.1 (2018-12-30)
+
+- On macOS, fix `Yen` (JIS) so applications receive the event.
+- On X11 with a tiling WM, fixed high CPU usage when moving windows across monitors.
+- On X11, fixed panic caused by dropping the window before running the event loop.
+- on macOS, added `WindowExt::set_simple_fullscreen` which does not require a separate space
+- Introduce `WindowBuilderExt::with_app_id` to allow setting the application ID on Wayland.
+- On Windows, catch panics in event loop child thread and forward them to the parent thread. This prevents an invocation of undefined behavior due to unwinding into foreign code.
+- On Windows, fix issue where resizing or moving window combined with grabbing the cursor would freeze program.
+- On Windows, fix issue where resizing or moving window would eat `Awakened` events.
+- On Windows, exiting fullscreen after entering fullscreen with disabled decorations no longer shrinks window.
+- On X11, fixed a segfault when using virtual monitors with XRandR.
+- Derive `Ord` and `PartialOrd` for `VirtualKeyCode` enum.
+- On Windows, fix issue where hovering or dropping a non file item would create a panic.
+- On Wayland, fix resizing and DPI calculation when a `wl_output` is removed without sending a `leave` event to the `wl_surface`, such as disconnecting a monitor from a laptop.
+- On Wayland, DPI calculation is handled by smithay-client-toolkit.
+- On X11, `WindowBuilder::with_min_dimensions` and `WindowBuilder::with_max_dimensions` now correctly account for DPI.
+- Added support for generating dummy `DeviceId`s and `WindowId`s to better support unit testing.
+- On macOS, fixed unsoundness in drag-and-drop that could result in drops being rejected.
+- On macOS, implemented `WindowEvent::Refresh`.
+- On macOS, all `MouseCursor` variants are now implemented and the cursor will no longer reset after unfocusing.
+- Removed minimum supported Rust version guarantee.
+
 # Version 0.18.0 (2018-11-07)
 
 - **Breaking:** `image` crate upgraded to 0.20. This is exposed as part of the `icon_loading` API.

CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# PLEASE MAKE PRs AGAINST THE `eventloop-2.0` BRANCH.
+
+All development work for our next version is being done against that branch. Refer to [#459](https://github.com/rust-windowing/winit/issues/459) and [the associated milestone](https://github.com/rust-windowing/winit/milestone/2) for details on what that branch changes.
+
+# Winit Contributing Guidelines
+
+## Scope
+[See `FEATURES.md`](./FEATURES.md). When requesting or implementing a new Winit feature, you should
+consider whether or not it's directly related to window creation or input handling. If it isn't, it
+may be worth creating a separate crate that extends Winit's API to add that functionality.
+
+
+## Reporting an issue
+
+When reporting an issue, in order to help the maintainers understand what the problem is, please make
+your description of the issue as detailed as possible:
+
+- if it is a bug, please provide clear explanation of what happens, what should happen, and how to
+  reproduce the issue, ideally by providing a minimal program exhibiting the problem
+- if it is a feature request, please provide a clear argumentation about why you believe this feature
+  should be supported by winit
+
+## Making a pull request
+
+When making a code contribution to winit, before opening your pull request, please make sure that:
+
+- you tested your modifications on all the platforms impacted, or if not possible detail which platforms
+  were not tested, and what should be tested, so that a maintainer or another contributor can test them
+- you updated any relevant documentation in winit
+- you left comments in your code explaining any part that is not straightforward, so that the
+  maintainers and future contributors don't have to try to guess what your code is supposed to do
+- your PR adds an entry to the changelog file if the introduced change is relevant to winit users
+- if your PR affects the platform compatibility of one or more features or adds another feature, the
+  relevant sections in [`FEATURES.md`](https://github.com/rust-windowing/winit/blob/master/FEATURES.md#features)
+  should be updated.
+
+Once your PR is open, you can ask for review by a maintainer of your platform. Winit's merging policy
+is that a PR must be approved by at least two maintainers of winit before being merged, including
+at least a maintainer of the platform (a maintainer making a PR themselves counts as approving it).
+
+## Maintainers & Testers
+
+Winit is managed by several people, each with their specialities, and each maintaining a subset of the
+backends of winit. As such, depending on your platform of interest, your contacts will be different.
+
+This table summarizes who can be contacted in which case, with the following legend:
+
+- `M` - Maintainer: is a main maintainer for this platform
+- `C` - Collaborator: can review code and address issues on this platform
+- `T` - Tester: has the ability of testing the platform
+- ` `: knows nothing of this platform
+
+| Platform            | Windows | macOS | X11   | Wayland | Android | iOS   | Emscripten |
+| :---                | :---:   | :---: | :---: | :---:   | :---:   | :---: | :---:      |
+| @mitchmindtree      | T       |       | T     | T       |         |       |            |
+| @Osspial            | M       |       | T     | T       | T       |       | T          |
+| @vberger            |         |       | T     | M       |         |       |            |
+| @mtak-              |         | T     |       |         | T       | M     |            |

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "winit"
-version = "0.18.0"
+version = "0.19.5"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
 license = "Apache-2.0"
 readme = "README.md"
-repository = "https://github.com/tomaka/winit"
+repository = "https://github.com/rust-windowing/winit"
 documentation = "https://docs.rs/winit"
 categories = ["gui"]
 
@@ -20,8 +20,9 @@ icon_loading = ["image"]
 lazy_static = "1"
 libc = "0.2"
 log = "0.4"
-image = { version = "0.20.1", optional = true }
+image = { version = "0.21", optional = true }
 serde = { version = "1", optional = true, features = ["serde_derive"] }
+raw-window-handle = "0.3"
 
 [target.'cfg(target_os = "android")'.dependencies.android_glue]
 version = "0.2"
@@ -35,6 +36,10 @@ cocoa = "0.18.4"
 core-foundation = "0.6"
 core-graphics = "0.17.3"
 
+[target.'cfg(target_os = "windows")'.dependencies]
+backtrace = "0.3"
+bitflags = "1"
+
 [target.'cfg(target_os = "windows")'.dependencies.winapi]
 version = "0.3.6"
 features = [
@@ -60,7 +65,7 @@ features = [
 
 [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
 wayland-client = { version = "0.21", features = [ "dlopen", "egl", "cursor"] }
-smithay-client-toolkit = "0.4"
+smithay-client-toolkit = "0.4.3"
 x11-dl = "2.18.3"
-parking_lot = "0.6"
-percent-encoding = "1.0"
+parking_lot = "0.9"
+percent-encoding = "2.0"

FEATURES.md

@@ -0,0 +1,209 @@
+# Winit Scope
+
+Winit aims to expose an interface that abstracts over window creation and input handling, and can
+be used to create both games and applications. It supports the main graphical platforms:
+- Desktop
+  - Windows
+  - macOS
+  - Unix
+    - via X11
+    - via Wayland
+- Mobile
+  - iOS
+  - Android
+- Web
+  - via Emscripten
+  - via WASM
+
+Most platforms expose capabilities that cannot be meaningfully transposed onto others. Winit does not
+aim to support every single feature of every platform, but rather to abstract over the common features
+available everywhere. In this context, APIs exposed in winit can be split into different "support tiers":
+
+- **Core:** Features that are essential to providing a well-formed abstraction over each platform's
+  windowing and input APIs.
+- **Platform:** Platform-specific features that can't be meaningfully exposed through a common API and
+  cannot be implemented outside of Winit without exposing a significant amount of Winit's internals
+  or interfering with Winit's abstractions.
+- **Usability:** Features that are not strictly essential to Winit's functionality, but provide meaningful
+  usability improvements and cannot be reasonably implemented in an external crate. These are
+  generally optional and exposed through Cargo features.
+
+Core features are taken care of by the core Winit maintainers. Platform features are not.
+When a platform feature is submitted, the submitter is considered the expert in the
+feature and may be asked to support the feature should it break in the future.
+
+Winit ***does not*** directly expose functionality for drawing inside windows or creating native
+menus, but ***does*** commit to providing APIs that higher-level crates can use to implement that
+functionality.
+
+## `1.0` and stability
+
+When all core features are implemented to the satisfaction of the Winit maintainers, Winit 1.0 will
+be released and the library will enter maintenance mode. For the most part, new core features will not
+be added past this point. New platform features may be accepted and exposed through point releases.
+
+### Tier upgrades
+Some platform features could in theory be exposed across multiple platforms, but have not gone
+through the implementation work necessary to function on all platforms. When one of these features
+gets implemented across all platforms, a PR can be opened to upgrade the feature to a core feature.
+If that gets accepted, the platform-specific functions gets deprecated and become permanently
+exposed through the core, cross-platform API.
+
+# Features
+
+## Extending this section
+
+If your PR makes notable changes to Winit's features, please update this section as follows:
+
+- If your PR adds a new feature, add a brief description to the relevant section. If the feature is a core
+  feature, add a row to the feature matrix and describe what platforms the feature has been implemented on.
+
+- If your PR begins a new API rework, add a row to the `Pending API Reworks` table. If the PR implements the
+  API rework on all relevant platforms, please move it to the `Completed API Reworks` table.
+
+- If your PR implements an already-existing feature on a new platform, either mark the feature as *completed*,
+  or mark it as *mostly completed* and link to an issue describing the problems with the implementation.
+
+## Core
+
+### Windowing
+- **Window initialization**: Winit allows the creation of a window
+- **Providing pointer to init OpenGL**: Winit provides the necessary pointers to initialize a working opengl context
+- **Providing pointer to init Vulkan**: Same as OpenGL but for Vulkan
+- **Window decorations**: The windows created by winit are properly decorated, and the decorations can
+  be deactivated
+- **Window decorations toggle**: Decorations can be turned on or off after window creation
+- **Window resizing**: The windows created by winit can be resized and generate the appropriate events
+  when they are. The application can precisely control its window size if desired.
+- **Window resize increments**: When the window gets resized, the application can choose to snap the window's
+  size to specific values.
+- **Window transparency**: Winit allows the creation of windows with a transparent background.
+- **Window maximization**: The windows created by winit can be maximized upon creation.
+- **Window maximization toggle**: The windows created by winit can be maximized and unmaximized after
+  creation.
+- **Fullscreen**: The windows created by winit can be put into fullscreen mode.
+- **Fullscreen toggle**: The windows created by winit can be switched to and from fullscreen after
+  creation.
+- **HiDPI support**: Winit assists developers in appropriately scaling HiDPI content.
+- **Popup / modal windows**: Windows can be created relative to the client area of other windows, and parent
+  windows can be disabled in favor of popup windows. This feature also guarantees that popup windows
+  get drawn above their owner.
+
+
+### System Information
+- **Monitor list**: Retrieve the list of monitors and their metadata, including which one is primary.
+
+### Input Handling
+- **Mouse events**: Generating mouse events associated with pointer motion, click, and scrolling events.
+- **Mouse set location**: Forcibly changing the location of the pointer.
+- **Cursor grab**: Locking the cursor so it cannot exit the client area of a window.
+- **Cursor icon**: Changing the cursor icon, or hiding the cursor.
+- **Touch events**: Single-touch events.
+- **Multitouch**: Multi-touch events, including cancellation of a gesture.
+- **Keyboard events**: Properly processing keyboard events using the user-specified keymap and
+  translating keypresses into UTF-8 characters, handling dead keys and IMEs.
+- **Drag & Drop**: Dragging content into winit, detecting when content enters, drops, or if the drop is cancelled.
+- **Raw Device Events**: Capturing input from input devices without any OS filtering.
+- **Gamepad/Joystick events**: Capturing input from gampads and joysticks.
+- **Device movement events:**: Capturing input from the device gyroscope and accelerometer.
+
+## Platform
+### Windows
+* Setting the taskbar icon
+* Setting the parent window
+* `WS_EX_NOREDIRECTIONBITMAP` support
+
+### macOS
+* Window activation policy
+* Window movable by background
+* Transparent titlebar
+* Hidden titlebar
+* Hidden titlebar buttons
+* Full-size content view
+
+### Unix
+* Window urgency
+* X11 Window Class
+* X11 Override Redirect Flag
+* GTK Theme Variant
+* Base window size
+
+## Usability
+* `serde`: Enables serialization/deserialization of certain types with Serde. (Maintainer: @Osspial)
+
+## Compatibility Matrix
+
+Legend:
+
+- ✔️: Works as intended
+- ▢: Mostly works but some bugs are known
+- ❌: Missing feature or large bugs making it unusable
+- **N/A**: Not applicable for this platform
+- ❓: Unknown status
+
+### Windowing
+|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |Emscripten|
+|-------------------------------- | ----- | ----   | -------    | -----------   | ----- | ----- | -------- |
+|Window initialization            |✔️     |✔️     |▢[#5]      |✔️             |▢[#33]|▢[#33] |❓        |
+|Providing pointer to init OpenGL |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |❓        |
+|Providing pointer to init Vulkan |✔️     |✔️     |✔️         |✔️             |✔️     |❓     |**N/A**   |
+|Window decorations               |✔️     |✔️     |✔️         |▢[#306]        |**N/A**|**N/A**|**N/A**   |
+|Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**   |
+|Window resizing                  |✔️     |▢[#219]|✔️         |▢[#306]        |**N/A**|**N/A**|❓        |
+|Window resize increments         |❌     |❌     |❌         |❌             |❌    |❌     |❌        |
+|Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**   |
+|Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**   |
+|Window maximization toggle       |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**   |
+|Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|❌        |
+|Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|❌        |
+|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |▢[#721]|✔️    |✔️         |
+|Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |❌        |
+
+### System information
+|Feature      |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Emscripten|
+|------------ | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
+|Monitor list |✔️    |✔️    |✔️       |✔️          |**N/A**|**N/A**|**N/A**   |
+
+### Input handling
+|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |Emscripten|
+|----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- |
+|Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️       |
+|Mouse set location      |✔️       |✔️      |✔️       |❓           |**N/A**|**N/A**|**N/A**  |
+|Cursor grab             |✔️       |▢[#165] |▢[#242]  |❌[#306]    |**N/A**|**N/A**|✔️       |
+|Cursor icon             |✔️       |✔️      |✔️       |❌[#306]    |**N/A**|**N/A**|❌       |
+|Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️       |
+|Multitouch              |❓        |❌      |✔️       |✔️          |❓     |❌     |❌       |
+|Keyboard events         |✔️       |✔️      |✔️       |✔️          |❓     |❌     |✔️       |
+|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |❌[#306]    |**N/A**|**N/A**|❓        |
+|Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❌       |
+|Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❌       |
+|Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❌       |
+
+### Pending API Reworks
+Changes in the API that have been agreed upon but aren't implemented across all platforms.
+
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Emscripten|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
+|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |▢[#721]|✔️    |✔️       |
+|Event Loop 2.0 ([#459])             |✔️    |❌    |❌       |✔️          |❌     |❌    |❌       |
+|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌     |❌      |
+
+### Completed API Reworks
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Emscripten|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
+
+[#165]: https://github.com/rust-windowing/winit/issues/165
+[#219]: https://github.com/rust-windowing/winit/issues/219
+[#242]: https://github.com/rust-windowing/winit/issues/242
+[#306]: https://github.com/rust-windowing/winit/issues/306
+[#315]: https://github.com/rust-windowing/winit/issues/315
+[#319]: https://github.com/rust-windowing/winit/issues/319
+[#33]: https://github.com/rust-windowing/winit/issues/33
+[#459]: https://github.com/rust-windowing/winit/issues/459
+[#5]: https://github.com/rust-windowing/winit/issues/5
+[#63]: https://github.com/rust-windowing/winit/issues/63
+[#720]: https://github.com/rust-windowing/winit/issues/720
+[#721]: https://github.com/rust-windowing/winit/issues/721
+[#750]: https://github.com/rust-windowing/winit/issues/750
+[#804]: https://github.com/rust-windowing/winit/issues/804
+[#812]: https://github.com/rust-windowing/winit/issues/812

HALL_OF_CHAMPIONS.md

@@ -0,0 +1,11 @@
+# Hall of Champions
+
+The Winit maintainers would like to recognize the following former Winit
+contributors, without whom Winit would not exist in its current form. We thank
+them deeply for their time and efforts, and wish them best of luck in their
+future endeavors:
+
+* @tomaka: For creating the Winit project and guiding it through its early
+  years of existence.
+* @francesca64: For taking over the responsibility of maintaining almost every
+  Winit backend, and standardizing HiDPI support across all of them

README.md

@@ -1,17 +1,35 @@
+# This branch has been archived
+
+Please direct all work against `master`.
+
+--------
+
 # winit - Cross-platform window creation and management in Rust
 
-[![](http://meritbadge.herokuapp.com/winit)](https://crates.io/crates/winit)
+[![Crates.io](https://img.shields.io/crates/v/winit.svg)](https://crates.io/crates/winit)
 [![Docs.rs](https://docs.rs/winit/badge.svg)](https://docs.rs/winit)
-[![Build Status](https://travis-ci.org/tomaka/winit.svg?branch=master)](https://travis-ci.org/tomaka/winit)
-[![Build status](https://ci.appveyor.com/api/projects/status/5h87hj0g4q2xe3j9/branch/master?svg=true)](https://ci.appveyor.com/project/tomaka/winit/branch/master)
+[![Build Status](https://travis-ci.org/rust-windowing/winit.svg?branch=master)](https://travis-ci.org/rust-windowing/winit)
+[![Build status](https://ci.appveyor.com/api/projects/status/hr89but4x1n3dphq/branch/master?svg=true)](https://ci.appveyor.com/project/Osspial/winit/branch/master)
 
 ```toml
 [dependencies]
-winit = "0.18"
+winit = "0.19.5"
 ```
 
 ## [Documentation](https://docs.rs/winit)
 
+For features _within_ the scope of winit, see [FEATURES.md](FEATURES.md).
+
+For features _outside_ the scope of winit, see [Missing features provided by other crates](https://github.com/rust-windowing/winit/wiki/Missing-features-provided-by-other-crates) in the wiki.
+
+## Contact Us
+
+Join us in any of these:
+
+[![Freenode](https://img.shields.io/badge/freenode.net-%23glutin-red.svg)](http://webchat.freenode.net?channels=%23glutin&uio=MTY9dHJ1ZSYyPXRydWUmND10cnVlJjExPTE4NSYxMj10cnVlJjE1PXRydWU7a)
+[![Matrix](https://img.shields.io/badge/Matrix-%23Glutin%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#Glutin:matrix.org)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/tomaka/glutin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 ## Usage
 
 Winit is a window creation and management library. It can create windows and lets you handle
@@ -41,6 +59,8 @@ fn main() {
 }
 ```
 
+Winit is only officially supported on the latest stable version of the Rust compiler.
+
 ### Cargo Features
 
 Winit provides the following features, which can be enabled in your `Cargo.toml` file:

appveyor.yml

@@ -4,8 +4,6 @@ environment:
     CHANNEL: nightly
   - TARGET: x86_64-pc-windows-msvc
     CHANNEL: stable
-  - TARGET: x86_64-pc-windows-msvc
-    CHANNEL: 1.24.1
   - TARGET: i686-pc-windows-msvc
     CHANNEL: nightly
   - TARGET: i686-pc-windows-gnu

examples/fullscreen.rs

@@ -6,35 +6,46 @@ use winit::{ControlFlow, Event, WindowEvent};
 fn main() {
     let mut events_loop = winit::EventsLoop::new();
 
-    // enumerating monitors
+    #[cfg(target_os = "macos")]
+    let mut macos_use_simple_fullscreen = false;
+
     let monitor = {
-        for (num, monitor) in events_loop.get_available_monitors().enumerate() {
-            println!("Monitor #{}: {:?}", num, monitor.get_name());
+        // On macOS there are two fullscreen modes "native" and "simple"
+        #[cfg(target_os = "macos")]
+        {
+            print!("Please choose the fullscreen mode: (1) native, (2) simple: ");
+            io::stdout().flush().unwrap();
+
+            let mut num = String::new();
+            io::stdin().read_line(&mut num).unwrap();
+            let num = num.trim().parse().ok().expect("Please enter a number");
+            match num {
+                2 => macos_use_simple_fullscreen = true,
+                _ => {}
+            }
+
+            // Prompt for monitor when using native fullscreen
+            if !macos_use_simple_fullscreen {
+                Some(prompt_for_monitor(&events_loop))
+            } else {
+                None
+            }
         }
 
-        print!("Please write the number of the monitor to use: ");
-        io::stdout().flush().unwrap();
-
-        let mut num = String::new();
-        io::stdin().read_line(&mut num).unwrap();
-        let num = num.trim().parse().ok().expect("Please enter a number");
-        let monitor = events_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
-
-        println!("Using {:?}", monitor.get_name());
-
-        monitor
+        #[cfg(not(target_os = "macos"))]
+        Some(prompt_for_monitor(&events_loop))
     };
 
+    let mut is_fullscreen = monitor.is_some();
+    let mut is_maximized = false;
+    let mut decorations = true;
+
     let window = winit::WindowBuilder::new()
         .with_title("Hello world!")
-        .with_fullscreen(Some(monitor))
+        .with_fullscreen(monitor)
         .build(&events_loop)
         .unwrap();
 
-    let mut is_fullscreen = true;
-    let mut is_maximized = false;
-    let mut decorations = true;
-
     events_loop.run_forever(|event| {
         println!("{:?}", event);
 
@@ -52,6 +63,18 @@ fn main() {
                 } => match (virtual_code, state) {
                     (winit::VirtualKeyCode::Escape, _) => return ControlFlow::Break,
                     (winit::VirtualKeyCode::F, winit::ElementState::Pressed) => {
+                        #[cfg(target_os = "macos")]
+                        {
+                            if macos_use_simple_fullscreen {
+                                use winit::os::macos::WindowExt;
+                                if WindowExt::set_simple_fullscreen(&window, !is_fullscreen) {
+                                    is_fullscreen = !is_fullscreen;
+                                }
+
+                                return ControlFlow::Continue;
+                            }
+                        }
+
                         is_fullscreen = !is_fullscreen;
                         if !is_fullscreen {
                             window.set_fullscreen(None);
@@ -59,6 +82,15 @@ fn main() {
                             window.set_fullscreen(Some(window.get_current_monitor()));
                         }
                     }
+                    (winit::VirtualKeyCode::S, winit::ElementState::Pressed) => {
+                        println!("window.get_fullscreen {:?}", window.get_fullscreen());
+
+                        #[cfg(target_os = "macos")]
+                        {
+                            use winit::os::macos::WindowExt;
+                            println!("window.get_simple_fullscreen {:?}", WindowExt::get_simple_fullscreen(&window));
+                        }
+                    }
                     (winit::VirtualKeyCode::M, winit::ElementState::Pressed) => {
                         is_maximized = !is_maximized;
                         window.set_maximized(is_maximized);
@@ -77,3 +109,22 @@ fn main() {
         ControlFlow::Continue
     });
 }
+
+// Enumerate monitors and prompt user to choose one
+fn prompt_for_monitor(events_loop: &winit::EventsLoop) -> winit::MonitorId {
+    for (num, monitor) in events_loop.get_available_monitors().enumerate() {
+        println!("Monitor #{}: {:?}", num, monitor.get_name());
+    }
+
+    print!("Please write the number of the monitor to use: ");
+    io::stdout().flush().unwrap();
+
+    let mut num = String::new();
+    io::stdin().read_line(&mut num).unwrap();
+    let num = num.trim().parse().ok().expect("Please enter a number");
+    let monitor = events_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
+
+    println!("Using {:?}", monitor.get_name());
+
+    monitor
+}

src/events.rs

@@ -37,12 +37,21 @@ pub enum WindowEvent {
     Destroyed,
 
     /// A file has been dropped into the window.
+    /// 
+    /// When the user drops multiple files at once, this event will be emitted for each file
+    /// separately.
     DroppedFile(PathBuf),
 
     /// A file is being hovered over the window.
+    /// 
+    /// When the user hovers multiple files at once, this event will be emitted for each file
+    /// separately.
     HoveredFile(PathBuf),
 
     /// A file was hovered, but has exited the window.
+    /// 
+    /// There will be a single `HoveredFileCancelled` event triggered even if multiple files were
+    /// hovered.
     HoveredFileCancelled,
 
     /// The window received a unicode character.
@@ -253,7 +262,7 @@ pub enum MouseScrollDelta {
 }
 
 /// Symbolic name for a keyboard key.
-#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy)]
 #[repr(u32)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum VirtualKeyCode {

src/lib.rs

@@ -98,6 +98,11 @@ extern crate serde;
 
 #[cfg(target_os = "windows")]
 extern crate winapi;
+#[cfg(target_os = "windows")]
+extern crate backtrace;
+#[macro_use]
+#[cfg(target_os = "windows")]
+extern crate bitflags;
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[macro_use]
 extern crate objc;
@@ -115,6 +120,7 @@ extern crate parking_lot;
 extern crate percent_encoding;
 #[cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 extern crate smithay_client_toolkit as sctk;
+extern crate raw_window_handle;
 
 pub(crate) use dpi::*; // TODO: Actually change the imports throughout the codebase.
 pub use events::*;
@@ -167,6 +173,17 @@ impl std::fmt::Debug for Window {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId(platform::WindowId);
 
+impl WindowId {
+    /// Returns a dummy `WindowId`, useful for unit testing. The only guarantee made about the return
+    /// value of this function is that it will always be equal to itself and to future values returned
+    /// by this function.  No other guarantees are made. This may be equal to a real `WindowId`.
+    ///
+    /// **Passing this into a winit function will result in undefined behavior.**
+    pub unsafe fn dummy() -> Self {
+        WindowId(platform::WindowId::dummy())
+    }
+}
+
 /// Identifier of an input device.
 ///
 /// Whenever you receive an event arising from a particular input device, this event contains a `DeviceId` which
@@ -175,6 +192,17 @@ pub struct WindowId(platform::WindowId);
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(platform::DeviceId);
 
+impl DeviceId {
+    /// Returns a dummy `DeviceId`, useful for unit testing. The only guarantee made about the return
+    /// value of this function is that it will always be equal to itself and to future values returned
+    /// by this function.  No other guarantees are made. This may be equal to a real `DeviceId`.
+    ///
+    /// **Passing this into a winit function will result in undefined behavior.**
+    pub unsafe fn dummy() -> Self {
+        DeviceId(platform::DeviceId::dummy())
+    }
+}
+
 /// Provides a way to retrieve events from the system and from the windows that were registered to
 /// the events loop.
 ///

src/os/macos.rs

@@ -22,6 +22,18 @@ pub trait WindowExt {
     /// - `false`: the dock icon will only bounce once.
     /// - `true`: the dock icon will bounce until the application is focused.
     fn request_user_attention(&self, is_critical: bool);
+
+    /// Returns whether or not the window is in simple fullscreen mode.
+    fn get_simple_fullscreen(&self) -> bool;
+
+    /// Toggles a fullscreen mode that doesn't require a new macOS space.
+    /// Returns a boolean indicating whether the transition was successful (this
+    /// won't work if the window was already in the native fullscreen).
+    ///
+    /// This is how fullscreen used to work on macOS in versions before Lion.
+    /// And allows the user to have a fullscreen window without using another
+    /// space or taking control over the entire monitor.
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool;
 }
 
 impl WindowExt for Window {
@@ -39,6 +51,16 @@ impl WindowExt for Window {
     fn request_user_attention(&self, is_critical: bool) {
         self.window.request_user_attention(is_critical)
     }
+
+    #[inline]
+    fn get_simple_fullscreen(&self) -> bool {
+        self.window.get_simple_fullscreen()
+    }
+
+    #[inline]
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
+        self.window.set_simple_fullscreen(fullscreen)
+    }
 }
 
 /// Corresponds to `NSApplicationActivationPolicy`.

src/os/unix.rs

@@ -4,6 +4,8 @@ use std::os::raw;
 use std::ptr;
 use std::sync::Arc;
 
+use sctk::window::{ButtonState, Theme};
+
 use {
     EventsLoop,
     LogicalSize,
@@ -25,6 +27,74 @@ pub use platform::x11;
 pub use platform::XNotSupported;
 pub use platform::x11::util::WindowType as XWindowType;
 
+/// Theme for wayland client side decorations
+///
+/// Colors must be in ARGB8888 format
+pub struct WaylandTheme {
+    /// Primary color when the window is focused
+    pub primary_active: [u8; 4],
+    /// Primary color when the window is unfocused
+    pub primary_inactive: [u8; 4],
+    /// Secondary color when the window is focused
+    pub secondary_active: [u8; 4],
+    /// Secondary color when the window is unfocused
+    pub secondary_inactive: [u8; 4],
+    /// Close button color when hovered over
+    pub close_button_hovered: [u8; 4],
+    /// Close button color
+    pub close_button: [u8; 4],
+    /// Close button color when hovered over
+    pub maximize_button_hovered: [u8; 4],
+    /// Maximize button color
+    pub maximize_button: [u8; 4],
+    /// Minimize button color when hovered over
+    pub minimize_button_hovered: [u8; 4],
+    /// Minimize button color
+    pub minimize_button: [u8; 4],
+}
+
+struct WaylandThemeObject(WaylandTheme);
+
+impl Theme for WaylandThemeObject {
+    fn get_primary_color(&self, active: bool) -> [u8; 4] {
+        if active {
+            self.0.primary_active
+        } else {
+            self.0.primary_inactive
+        }
+    }
+
+    // Used for division line
+    fn get_secondary_color(&self, active: bool) -> [u8; 4] {
+        if active {
+            self.0.secondary_active
+        } else {
+            self.0.secondary_inactive
+        }
+    }
+
+    fn get_close_button_color(&self, state: ButtonState) -> [u8; 4] {
+        match state {
+            ButtonState::Hovered => self.0.close_button_hovered,
+            _ => self.0.close_button,
+        }
+    }
+
+    fn get_maximize_button_color(&self, state: ButtonState) -> [u8; 4] {
+        match state {
+            ButtonState::Hovered => self.0.maximize_button_hovered,
+            _ => self.0.maximize_button,
+        }
+    }
+
+    fn get_minimize_button_color(&self, state: ButtonState) -> [u8; 4] {
+        match state {
+            ButtonState::Hovered => self.0.minimize_button_hovered,
+            _ => self.0.minimize_button,
+        }
+    }
+}
+
 /// Additional methods on `EventsLoop` that are specific to Linux.
 pub trait EventsLoopExt {
     /// Builds a new `EventsLoop` that is forced to use X11.
@@ -43,6 +113,13 @@ pub trait EventsLoopExt {
 
     #[doc(hidden)]
     fn get_xlib_xconnection(&self) -> Option<Arc<XConnection>>;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this `EventsLoop`.
+    ///
+    /// Returns `None` if the `EventsLoop` doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the glutin `EventsLoop` is destroyed.
+    fn get_wayland_display(&self) -> Option<*mut raw::c_void>;
 }
 
 impl EventsLoopExt for EventsLoop {
@@ -82,6 +159,14 @@ impl EventsLoopExt for EventsLoop {
     fn get_xlib_xconnection(&self) -> Option<Arc<XConnection>> {
         self.events_loop.x_connection().cloned()
     }
+
+    #[inline]
+    fn get_wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.events_loop {
+            LinuxEventsLoop::Wayland(ref e) => Some(e.get_display().c_ptr() as *mut _),
+            _ => None
+        }
+    }
 }
 
 /// Additional methods on `Window` that are specific to Unix.
@@ -127,6 +212,9 @@ pub trait WindowExt {
     /// The pointer will become invalid when the glutin `Window` is destroyed.
     fn get_wayland_display(&self) -> Option<*mut raw::c_void>;
 
+    /// Sets the color theme of the client side window decorations on wayland
+    fn set_wayland_theme(&self, theme: WaylandTheme);
+
     /// Check if the window is ready for drawing
     ///
     /// It is a remnant of a previous implementation detail for the
@@ -202,6 +290,14 @@ impl WindowExt for Window {
         }
     }
 
+    #[inline]
+    fn set_wayland_theme(&self, theme: WaylandTheme) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_theme(WaylandThemeObject(theme)),
+            _ => {}
+        }
+    }
+
     #[inline]
     fn is_ready(&self) -> bool {
         true
@@ -225,6 +321,13 @@ pub trait WindowBuilderExt {
     fn with_resize_increments(self, increments: LogicalSize) -> WindowBuilder;
     /// Build window with base size hint. Only implemented on X11.
     fn with_base_size(self, base_size: LogicalSize) -> WindowBuilder;
+
+    /// Build window with a given application ID. It should match the `.desktop` file distributed with
+    /// your program. Only relevant on Wayland.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_app_id(self, app_id: String) -> WindowBuilder;
 }
 
 impl WindowBuilderExt for WindowBuilder {
@@ -277,6 +380,12 @@ impl WindowBuilderExt for WindowBuilder {
         self.platform_specific.gtk_theme_variant = Some(variant);
         self
     }
+
+    #[inline]
+    fn with_app_id(mut self, app_id: String) -> WindowBuilder {
+        self.platform_specific.app_id = Some(app_id);
+        self
+    }
 }
 
 /// Additional methods on `MonitorId` that are specific to Linux.

src/platform/android/mod.rs

@@ -4,6 +4,7 @@ extern crate android_glue;
 
 mod ffi;
 
+use raw_window_handle::{android::AndroidHandle, RawWindowHandle};
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::fmt;
@@ -170,9 +171,21 @@ impl EventsLoopProxy {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId;
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        WindowId
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId
+    }
+}
+
 pub struct Window {
     native_window: *const c_void,
 }
@@ -356,6 +369,13 @@ impl Window {
         // Android has single screen maximized apps so nothing to do
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        // N/A
+        // Android has single screen maximized apps so nothing to do
+        None
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, _monitor: Option<RootMonitorId>) {
         // N/A
@@ -403,6 +423,14 @@ impl Window {
     pub fn id(&self) -> WindowId {
         WindowId
     }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let handle = AndroidHandle {
+            a_native_window: self.native_window as _,
+            ..AndroidHandle::empty()
+        };
+        RawWindowHandle::Android(handle)
+    }
 }
 
 unsafe impl Send for Window {}

src/platform/emscripten/mod.rs

@@ -27,6 +27,12 @@ unsafe impl Sync for PlatformSpecificWindowBuilderAttributes {}
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct PlatformSpecificHeadlessBuilderAttributes;
 
@@ -149,6 +155,12 @@ impl EventsLoop {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId(usize);
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        WindowId(0)
+    }
+}
+
 pub struct Window2 {
     cursor_grabbed: Mutex<bool>,
     cursor_hidden: Mutex<bool>,
@@ -568,6 +580,11 @@ impl Window {
         // iOS has single screen maximized apps so nothing to do
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<::MonitorId> {
+        None
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, _monitor: Option<::MonitorId>) {
         // iOS has single screen maximized apps so nothing to do

src/platform/ios/mod.rs

@@ -60,6 +60,7 @@
 
 #![cfg(target_os = "ios")]
 
+use raw_window_handle::{ios::IOSHandle, RawWindowHandle};
 use std::{fmt, mem, ptr};
 use std::cell::RefCell;
 use std::collections::VecDeque;
@@ -290,9 +291,21 @@ impl EventsLoopProxy {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId;
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        WindowId
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId
+    }
+}
+
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
     pub root_view_class: &'static Class,
@@ -461,6 +474,13 @@ impl Window {
         // iOS has single screen maximized apps so nothing to do
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        // N/A
+        // iOS has single screen maximized apps so nothing to do
+        None
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, _monitor: Option<RootMonitorId>) {
         // N/A
@@ -508,6 +528,15 @@ impl Window {
     pub fn id(&self) -> WindowId {
         WindowId
     }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let handle = IOSHandle {
+            ui_window: self.get_uiwindow() as *mut _,
+            ui_view: self.get_uiview() as *mut _,
+            ..IOSHandle::empty()
+        };
+        RawWindowHandle::IOS(handle)
+    }
 }
 
 fn create_delegate_class() {

src/platform/linux/dlopen.rs

@@ -6,7 +6,7 @@ use std::os::raw::{c_void, c_char, c_int};
 pub const RTLD_LAZY: c_int = 0x001;
 pub const RTLD_NOW: c_int = 0x002;
 
-#[link="dl"]
+#[link(name = "dl")]
 extern {
     pub fn dlopen(filename: *const c_char, flag: c_int) -> *mut c_void;
     pub fn dlerror() -> *mut c_char;

src/platform/linux/mod.rs

@@ -7,6 +7,7 @@ use std::os::raw::*;
 use std::sync::Arc;
 
 use parking_lot::Mutex;
+use raw_window_handle::RawWindowHandle;
 use sctk::reexports::client::ConnectError;
 
 use {
@@ -46,6 +47,7 @@ pub struct PlatformSpecificWindowBuilderAttributes {
     pub override_redirect: bool,
     pub x11_window_type: x11::util::WindowType,
     pub gtk_theme_variant: Option<String>,
+    pub app_id: Option<String>
 }
 
 lazy_static!(
@@ -65,12 +67,24 @@ pub enum WindowId {
     Wayland(wayland::WindowId),
 }
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        WindowId::X(x11::WindowId::dummy())
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum DeviceId {
     X(x11::DeviceId),
     Wayland(wayland::DeviceId),
 }
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId::X(x11::DeviceId::dummy())
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum MonitorId {
     X(x11::MonitorId),
@@ -128,7 +142,7 @@ impl Window {
     ) -> Result<Self, CreationError> {
         match *events_loop {
             EventsLoop::Wayland(ref events_loop) => {
-                wayland::Window::new(events_loop, attribs).map(Window::Wayland)
+                wayland::Window::new(events_loop, attribs, pl_attribs).map(Window::Wayland)
             },
             EventsLoop::X(ref events_loop) => {
                 x11::Window::new(events_loop, attribs, pl_attribs).map(Window::X)
@@ -288,6 +302,15 @@ impl Window {
         }
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        match self {
+            &Window::X(ref w) => w.get_fullscreen(),
+            &Window::Wayland(ref w) => w.get_fullscreen()
+                .map(|monitor_id| RootMonitorId { inner: MonitorId::Wayland(monitor_id) })
+        }
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
         match self {
@@ -357,6 +380,13 @@ impl Window {
             &Window::Wayland(ref window) => MonitorId::Wayland(window.get_primary_monitor()),
         }
     }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        match self {
+            &Window::X(ref window) => RawWindowHandle::Xlib(window.raw_window_handle()),
+            &Window::Wayland(ref window) => RawWindowHandle::Wayland(window.raw_window_handle()),
+        }
+    }
 }
 
 unsafe extern "C" fn x_error_callback(
@@ -381,7 +411,7 @@ unsafe extern "C" fn x_error_callback(
             minor_code: (*event).minor_code,
         };
 
-        eprintln!("[winit X11 error] {:#?}", error);
+        error!("X11 error: {:#?}", error);
 
         *xconn.latest_error.lock() = Some(error);
     }

src/platform/linux/wayland/event_loop.rs

@@ -126,8 +126,19 @@ impl EventsLoop {
         let env = Environment::from_display_with_cb(
             &display,
             &mut event_queue,
-            move |event, registry| { 
-                seat_manager.receive(event, registry)
+            move |event, registry| {
+                match event {
+                    GlobalEvent::New { id, ref interface, version } => {
+                        if interface == "wl_seat" {
+                            seat_manager.add_seat(id, version, registry)
+                        }
+                    },
+                    GlobalEvent::Removed { id, ref interface } => {
+                        if interface == "wl_seat" {
+                            seat_manager.remove_seat(id)
+                        }
+                    },
+                }
             },
         ).unwrap();
 
@@ -218,6 +229,10 @@ impl EventsLoop {
     pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
         get_available_monitors(&self.env.outputs)
     }
+
+    pub fn get_display(&self) -> &Display {
+        &*self.display
+    }
 }
 
 /*
@@ -286,47 +301,38 @@ struct SeatManager {
 }
 
 impl SeatManager {
-    fn receive(&mut self, evt: GlobalEvent, registry: Proxy<wl_registry::WlRegistry>) {
+    fn add_seat(&mut self, id: u32, version: u32, registry: Proxy<wl_registry::WlRegistry>) {
         use self::wl_registry::RequestsTrait as RegistryRequests;
-        use self::wl_seat::RequestsTrait as SeatRequests;
-        match evt {
-            GlobalEvent::New {
-                id,
-                ref interface,
-                version,
-            } if interface == "wl_seat" =>
-            {
-                use std::cmp::min;
+        use std::cmp::min;
 
-                let mut seat_data = SeatData {
-                    sink: self.sink.clone(),
-                    store: self.store.clone(),
-                    pointer: None,
-                    keyboard: None,
-                    touch: None,
-                    events_loop_proxy: self.events_loop_proxy.clone(),
-                    modifiers_tracker: Arc::new(Mutex::new(ModifiersState::default())),
-                };
-                let seat = registry
-                    .bind(min(version, 5), id, move |seat| {
-                        seat.implement(move |event, seat| {
-                            seat_data.receive(event, seat)
-                        }, ())
-                    })
-                    .unwrap();
-                self.store.lock().unwrap().new_seat(&seat);
-                self.seats.lock().unwrap().push((id, seat));
+        let mut seat_data = SeatData {
+            sink: self.sink.clone(),
+            store: self.store.clone(),
+            pointer: None,
+            keyboard: None,
+            touch: None,
+            events_loop_proxy: self.events_loop_proxy.clone(),
+            modifiers_tracker: Arc::new(Mutex::new(ModifiersState::default())),
+        };
+        let seat = registry
+            .bind(min(version, 5), id, move |seat| {
+                seat.implement(move |event, seat| {
+                    seat_data.receive(event, seat)
+                }, ())
+            })
+            .unwrap();
+        self.store.lock().unwrap().new_seat(&seat);
+        self.seats.lock().unwrap().push((id, seat));
+    }
+
+    fn remove_seat(&mut self, id: u32) {
+        use self::wl_seat::RequestsTrait as SeatRequests;
+        let mut seats = self.seats.lock().unwrap();
+        if let Some(idx) = seats.iter().position(|&(i, _)| i == id) {
+            let (_, seat) = seats.swap_remove(idx);
+            if seat.version() >= 5 {
+                seat.release();
             }
-            GlobalEvent::Removed { id, ref interface } if interface == "wl_seat" => {
-                let mut seats = self.seats.lock().unwrap();
-                if let Some(idx) = seats.iter().position(|&(i, _)| i == id) {
-                    let (_, seat) = seats.swap_remove(idx);
-                    if seat.version() >= 5 {
-                        seat.release();
-                    }
-                }
-            }
-            _ => (),
         }
     }
 }

src/platform/linux/wayland/keyboard.rs

@@ -312,6 +312,13 @@ fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
         keysyms::XKB_KEY_KP_Separator => Some(VirtualKeyCode::NumpadComma),
         keysyms::XKB_KEY_KP_Enter => Some(VirtualKeyCode::NumpadEnter),
         keysyms::XKB_KEY_KP_Equal => Some(VirtualKeyCode::NumpadEquals),
+        keysyms::XKB_KEY_KP_Add => Some(VirtualKeyCode::Add),
+        keysyms::XKB_KEY_KP_Subtract => Some(VirtualKeyCode::Subtract),
+        keysyms::XKB_KEY_KP_Divide => Some(VirtualKeyCode::Divide),
+        keysyms::XKB_KEY_KP_Page_Up => Some(VirtualKeyCode::PageUp),
+        keysyms::XKB_KEY_KP_Page_Down => Some(VirtualKeyCode::PageDown),
+        keysyms::XKB_KEY_KP_Home => Some(VirtualKeyCode::Home),
+        keysyms::XKB_KEY_KP_End => Some(VirtualKeyCode::End),
         // => Some(VirtualKeyCode::OEM102),
         // => Some(VirtualKeyCode::Period),
         // => Some(VirtualKeyCode::Playpause),

src/platform/linux/wayland/window.rs

@@ -1,15 +1,16 @@
+use raw_window_handle::unix::WaylandHandle;
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex, Weak};
 
 use {CreationError, MouseCursor, WindowAttributes};
 use dpi::{LogicalPosition, LogicalSize};
-use platform::MonitorId as PlatformMonitorId;
+use platform::{MonitorId as PlatformMonitorId, PlatformSpecificWindowBuilderAttributes as PlAttributes};
 use window::MonitorId as RootMonitorId;
 
-use sctk::window::{ConceptFrame, Event as WEvent, Window as SWindow};
+use sctk::surface::{get_dpi_factor, get_outputs};
+use sctk::window::{ConceptFrame, Event as WEvent, State as WState, Window as SWindow, Theme};
 use sctk::reexports::client::{Display, Proxy};
-use sctk::reexports::client::protocol::{wl_seat, wl_surface, wl_output};
-use sctk::reexports::client::protocol::wl_compositor::RequestsTrait as CompositorRequests;
+use sctk::reexports::client::protocol::{wl_seat, wl_surface};
 use sctk::reexports::client::protocol::wl_surface::RequestsTrait as SurfaceRequests;
 use sctk::output::OutputMgr;
 
@@ -19,53 +20,26 @@ use platform::platform::wayland::event_loop::{get_available_monitors, get_primar
 pub struct Window {
     surface: Proxy<wl_surface::WlSurface>,
     frame: Arc<Mutex<SWindow<ConceptFrame>>>,
-    monitors: Arc<Mutex<MonitorList>>, // Monitors this window is currently on
     outputs: OutputMgr, // Access to info for all monitors
     size: Arc<Mutex<(u32, u32)>>,
     kill_switch: (Arc<Mutex<bool>>, Arc<Mutex<bool>>),
     display: Arc<Display>,
     need_frame_refresh: Arc<Mutex<bool>>,
+    fullscreen: Arc<Mutex<bool>>,
 }
 
 impl Window {
-    pub fn new(evlp: &EventsLoop, attributes: WindowAttributes) -> Result<Window, CreationError> {
+    pub fn new(evlp: &EventsLoop, attributes: WindowAttributes, pl_attribs: PlAttributes) -> Result<Window, CreationError> {
         let (width, height) = attributes.dimensions.map(Into::into).unwrap_or((800, 600));
         // Create the window
         let size = Arc::new(Mutex::new((width, height)));
+        let fullscreen = Arc::new(Mutex::new(false));
 
-        // monitor tracking
-        let monitor_list = Arc::new(Mutex::new(MonitorList::new()));
-
-        let surface = evlp.env.compositor.create_surface(|surface| {
-            let list = monitor_list.clone();
-            let omgr = evlp.env.outputs.clone();
-            let window_store = evlp.store.clone();
-            surface.implement(move |event, surface| match event {
-                wl_surface::Event::Enter { output } => {
-                    let dpi_change = list.lock().unwrap().add_output(MonitorId {
-                        proxy: output,
-                        mgr: omgr.clone(),
-                    });
-                    if let Some(dpi) = dpi_change {
-                        if surface.version() >= 3 {
-                            // without version 3 we can't be dpi aware
-                            window_store.lock().unwrap().dpi_change(&surface, dpi);
-                            surface.set_buffer_scale(dpi);
-                        }
-                    }
-                },
-                wl_surface::Event::Leave { output } => {
-                    let dpi_change = list.lock().unwrap().del_output(&output);
-                    if let Some(dpi) = dpi_change {
-                        if surface.version() >= 3 {
-                            // without version 3 we can't be dpi aware
-                            window_store.lock().unwrap().dpi_change(&surface, dpi);
-                            surface.set_buffer_scale(dpi);
-                        }
-                    }
-                }
-            }, ())
-        }).unwrap();
+        let window_store = evlp.store.clone();
+        let surface = evlp.env.create_surface(move |dpi, surface| {
+            window_store.lock().unwrap().dpi_change(&surface, dpi);
+            surface.set_buffer_scale(dpi);
+        });
 
         let window_store = evlp.store.clone();
         let my_surface = surface.clone();
@@ -74,12 +48,15 @@ impl Window {
             surface.clone(),
             (width, height),
             move |event| match event {
-                WEvent::Configure { new_size, .. } => {
+                WEvent::Configure { new_size, states } => {
                     let mut store = window_store.lock().unwrap();
+                    let is_fullscreen = states.contains(&WState::Fullscreen);
+
                     for window in &mut store.windows {
                         if window.surface.equals(&my_surface) {
                             window.newsize = new_size;
                             window.need_refresh = true;
+                            *(window.fullscreen.lock().unwrap()) = is_fullscreen;
                             *(window.need_frame_refresh.lock().unwrap()) = true;
                             return;
                         }
@@ -106,6 +83,12 @@ impl Window {
             },
         ).unwrap();
 
+        if let Some(app_id) = pl_attribs.app_id {
+            frame.set_app_id(app_id);
+        }
+
+        frame.set_title(attributes.title);
+
         for &(_, ref seat) in evlp.seats.lock().unwrap().iter() {
             frame.new_seat(seat);
         }
@@ -137,6 +120,7 @@ impl Window {
             closed: false,
             newsize: None,
             size: size.clone(),
+            fullscreen: fullscreen.clone(),
             need_refresh: false,
             need_frame_refresh: need_frame_refresh.clone(),
             surface: surface.clone(),
@@ -151,11 +135,11 @@ impl Window {
             display: evlp.display.clone(),
             surface: surface,
             frame: frame,
-            monitors: monitor_list,
             outputs: evlp.env.outputs.clone(),
             size: size,
             kill_switch: (kill_switch, evlp.cleanup_needed.clone()),
             need_frame_refresh: need_frame_refresh,
+            fullscreen: fullscreen,
         })
     }
 
@@ -231,7 +215,7 @@ impl Window {
 
     #[inline]
     pub fn hidpi_factor(&self) -> i32 {
-        self.monitors.lock().unwrap().compute_hidpi_factor()
+        get_dpi_factor(&self.surface)
     }
 
     pub fn set_decorations(&self, decorate: bool) {
@@ -247,6 +231,14 @@ impl Window {
         }
     }
 
+    pub fn get_fullscreen(&self) -> Option<MonitorId> {
+        if *(self.fullscreen.lock().unwrap()) {
+            Some(self.get_current_monitor())
+        } else {
+            None
+        }
+    }
+
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
         if let Some(RootMonitorId {
             inner: PlatformMonitorId::Wayland(ref monitor_id),
@@ -261,6 +253,11 @@ impl Window {
         }
     }
 
+
+    pub fn set_theme<T: Theme>(&self, theme: T) {
+        self.frame.lock().unwrap().set_theme(theme)
+    }
+
     #[inline]
     pub fn set_cursor(&self, _cursor: MouseCursor) {
         // TODO
@@ -290,10 +287,11 @@ impl Window {
     }
 
     pub fn get_current_monitor(&self) -> MonitorId {
-        // we don't know how much each monitor sees us so...
-        // just return the most recent one ?
-        let guard = self.monitors.lock().unwrap();
-        guard.monitors.last().unwrap().clone()
+        let output = get_outputs(&self.surface).last().unwrap().clone();
+        MonitorId {
+            proxy: output,
+            mgr: self.outputs.clone(),
+        }
     }
 
     pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
@@ -303,6 +301,14 @@ impl Window {
     pub fn get_primary_monitor(&self) -> MonitorId {
         get_primary_monitor(&self.outputs)
     }
+
+    pub fn raw_window_handle(&self) -> WaylandHandle {
+        WaylandHandle {
+            surface: self.get_surface().c_ptr() as *mut _,
+            display: self.get_display().c_ptr() as *mut _,
+            ..WaylandHandle::empty()
+        }
+    }
 }
 
 impl Drop for Window {
@@ -320,13 +326,14 @@ struct InternalWindow {
     surface: Proxy<wl_surface::WlSurface>,
     newsize: Option<(u32, u32)>,
     size: Arc<Mutex<(u32, u32)>>,
+    fullscreen: Arc<Mutex<bool>>,
     need_refresh: bool,
     need_frame_refresh: Arc<Mutex<bool>>,
     closed: bool,
     kill_switch: Arc<Mutex<bool>>,
     frame: Weak<Mutex<SWindow<ConceptFrame>>>,
     current_dpi: i32,
-    new_dpi: Option<i32>
+    new_dpi: Option<i32>,
 }
 
 pub struct WindowStore {
@@ -406,50 +413,3 @@ impl WindowStore {
         }
     }
 }
-
-/*
- * Monitor list with some covenience method to compute DPI
- */
-
-struct MonitorList {
-    monitors: Vec<MonitorId>
-}
-
-impl MonitorList {
-    fn new() -> MonitorList {
-        MonitorList {
-            monitors: Vec::new()
-        }
-    }
-
-    fn compute_hidpi_factor(&self) -> i32 {
-        let mut factor = 1;
-        for monitor_id in &self.monitors {
-            let monitor_dpi = monitor_id.get_hidpi_factor();
-            if monitor_dpi > factor { factor = monitor_dpi; }
-        }
-        factor
-    }
-
-    fn add_output(&mut self, monitor: MonitorId) -> Option<i32> {
-        let old_dpi = self.compute_hidpi_factor();
-        let monitor_dpi = monitor.get_hidpi_factor();
-        self.monitors.push(monitor);
-        if monitor_dpi > old_dpi {
-            Some(monitor_dpi)
-        } else {
-            None
-        }
-    }
-
-    fn del_output(&mut self, output: &Proxy<wl_output::WlOutput>) -> Option<i32> {
-        let old_dpi = self.compute_hidpi_factor();
-        self.monitors.retain(|m| !m.proxy.equals(output));
-        let new_dpi = self.compute_hidpi_factor();
-        if new_dpi != old_dpi {
-            Some(new_dpi)
-        } else {
-            None
-        }
-    }
-}

src/platform/linux/x11/events.rs

@@ -82,11 +82,11 @@ pub fn keysym_to_element(keysym: libc::c_uint) -> Option<VirtualKeyCode> {
         ffi::XK_KP_Delete => events::VirtualKeyCode::Delete,
         ffi::XK_KP_Equal => events::VirtualKeyCode::NumpadEquals,
         //ffi::XK_KP_Multiply => events::VirtualKeyCode::NumpadMultiply,
-        //ffi::XK_KP_Add => events::VirtualKeyCode::NumpadAdd,
+        ffi::XK_KP_Add => events::VirtualKeyCode::Add,
         //ffi::XK_KP_Separator => events::VirtualKeyCode::Kp_separator,
-        //ffi::XK_KP_Subtract => events::VirtualKeyCode::NumpadSubtract,
+        ffi::XK_KP_Subtract => events::VirtualKeyCode::Subtract,
         //ffi::XK_KP_Decimal => events::VirtualKeyCode::Kp_decimal,
-        //ffi::XK_KP_Divide => events::VirtualKeyCode::NumpadDivide,
+        ffi::XK_KP_Divide => events::VirtualKeyCode::Divide,
         ffi::XK_KP_0 => events::VirtualKeyCode::Numpad0,
         ffi::XK_KP_1 => events::VirtualKeyCode::Numpad1,
         ffi::XK_KP_2 => events::VirtualKeyCode::Numpad2,

src/platform/linux/x11/mod.rs

@@ -19,6 +19,13 @@ use std::collections::HashMap;
 use std::ffi::CStr;
 use std::ops::Deref;
 use std::os::raw::*;
+use libc::{select, fd_set, FD_SET, FD_ZERO, FD_ISSET, EINTR, EINVAL, ENOMEM, EBADF};
+#[cfg(target_os = "linux")]
+use libc::__errno_location;
+#[cfg(target_os = "freebsd")]
+use libc::__error as __errno_location;
+#[cfg(any(target_os = "netbsd", target_os = "openbsd"))]
+use libc::__errno as __errno_location;
 use std::sync::{Arc, mpsc, Weak};
 use std::sync::atomic::{self, AtomicBool};
 
@@ -185,6 +192,70 @@ impl EventsLoop {
         }
     }
 
+    unsafe fn poll_one_event(&mut self, event_ptr : *mut ffi::XEvent) -> bool {
+        // This function is used to poll and remove a single event
+        // from the Xlib event queue in a non-blocking, atomic way.
+        // XCheckIfEvent is non-blocking and removes events from queue.
+        // XNextEvent can't be used because it blocks while holding the
+        // global Xlib mutex.
+        // XPeekEvent does not remove events from the queue.
+        unsafe extern "C" fn predicate(
+            _display: *mut ffi::Display,
+            _event: *mut ffi::XEvent,
+            _arg : *mut c_char)  -> c_int {
+            // This predicate always returns "true" (1) to accept all events
+            1
+        }
+
+        let result = (self.xconn.xlib.XCheckIfEvent)(
+            self.xconn.display,
+            event_ptr,
+            Some(predicate),
+            std::ptr::null_mut());
+
+        result != 0
+    }
+
+    unsafe fn wait_for_input(&mut self) {
+        // XNextEvent can not be used in multi-threaded applications
+        // because it is blocking for input while holding the global
+        // Xlib mutex.
+        // To work around this issue, first flush the X11 display, then
+        // use select(2) to wait for input to arrive
+        loop {
+            // First use XFlush to flush any buffered x11 requests
+            (self.xconn.xlib.XFlush)(self.xconn.display);
+
+            // Then use select(2) to wait for input data
+            let mut fds : fd_set = mem::uninitialized();
+            FD_ZERO(&mut fds);
+            FD_SET(self.xconn.x11_fd, &mut fds);
+            let err = select(
+                self.xconn.x11_fd + 1,
+                &mut fds, // read fds
+                std::ptr::null_mut(), // write fds
+                std::ptr::null_mut(), // except fds (could be used to detect errors)
+                std::ptr::null_mut()); // timeout
+
+            if err < 0 {
+                let errno_ptr = __errno_location();
+                let errno = *errno_ptr;
+
+                if errno == EINTR {
+                    // try again if errno is EINTR
+                    continue;
+                }
+
+                assert!(errno == EBADF || errno == EINVAL || errno == ENOMEM);
+                panic!("select(2) returned fatal error condition");
+            }
+
+            if FD_ISSET(self.xconn.x11_fd, &mut fds) {
+                break;
+            }
+        }
+    }
+
     pub fn poll_events<F>(&mut self, mut callback: F)
         where F: FnMut(Event)
     {
@@ -192,13 +263,9 @@ impl EventsLoop {
         loop {
             // Get next event
             unsafe {
-                // Ensure XNextEvent won't block
-                let count = (self.xconn.xlib.XPending)(self.xconn.display);
-                if count == 0 {
+                if !self.poll_one_event(&mut xev) {
                     break;
                 }
-
-                (self.xconn.xlib.XNextEvent)(self.xconn.display, &mut xev);
             }
             self.process_event(&mut xev, &mut callback);
         }
@@ -210,7 +277,12 @@ impl EventsLoop {
         let mut xev = unsafe { mem::uninitialized() };
 
         loop {
-            unsafe { (self.xconn.xlib.XNextEvent)(self.xconn.display, &mut xev) }; // Blocks as necessary
+            unsafe {
+                while !self.poll_one_event(&mut xev) {
+                    // block until input is available
+                    self.wait_for_input();
+                }
+            };
 
             let mut control_flow = ControlFlow::Continue;
 
@@ -499,10 +571,12 @@ impl EventsLoop {
                     }
 
                     // This is a hack to ensure that the DPI adjusted resize is actually applied on all WMs. KWin
-                    // doesn't need this, but Xfwm does.
+                    // doesn't need this, but Xfwm does. The hack should not be run on other WMs, since tiling
+                    // WMs constrain the window size, making the resize fail. This would cause an endless stream of
+                    // XResizeWindow requests, making Xorg, the winit client, and the WM consume 100% of CPU.
                     if let Some(adjusted_size) = shared_state_lock.dpi_adjusted {
                         let rounded_size = (adjusted_size.0.round() as u32, adjusted_size.1.round() as u32);
-                        if new_inner_size == rounded_size {
+                        if new_inner_size == rounded_size || !util::wm_name_is_one_of(&["Xfwm4"]) {
                             // When this finally happens, the event will not be synthetic.
                             shared_state_lock.dpi_adjusted = None;
                         } else {
@@ -864,20 +938,26 @@ impl EventsLoop {
                             event: CursorEntered { device_id },
                         });
 
-                        // The mods field on this event isn't actually populated, so query the
-                        // pointer device. In the future, we can likely remove this round-trip by
-                        // relying on Xkb for modifier values.
-                        let modifiers = self.xconn.query_pointer(xev.event, xev.deviceid)
-                            .expect("Failed to query pointer device").get_modifier_state();
-
-                        let dpi_factor = self.with_window(xev.event, |window| {
+                        if let Some(dpi_factor) = self.with_window(xev.event, |window| {
                             window.get_hidpi_factor()
-                        });
-                        if let Some(dpi_factor) = dpi_factor {
+                        }) {
                             let position = LogicalPosition::from_physical(
                                 (xev.event_x as f64, xev.event_y as f64),
                                 dpi_factor,
                             );
+
+                            // The mods field on this event isn't actually populated, so query the
+                            // pointer device. In the future, we can likely remove this round-trip by
+                            // relying on `Xkb` for modifier values.
+                            //
+                            // This needs to only be done after confirming the window still exists,
+                            // since otherwise we risk getting a `BadWindow` error if the window was
+                            // dropped with queued events.
+                            let modifiers = self.xconn
+                                .query_pointer(xev.event, xev.deviceid)
+                                .expect("Failed to query pointer device")
+                                .get_modifier_state();
+
                             callback(Event::WindowEvent {
                                 window_id,
                                 event: CursorMoved {
@@ -1254,9 +1334,21 @@ impl<'a> Deref for DeviceInfo<'a> {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId(ffi::Window);
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        WindowId(0)
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(c_int);
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId(0)
+    }
+}
+
 pub struct Window(Arc<UnownedWindow>);
 
 impl Deref for Window {

src/platform/linux/x11/monitor.rs

@@ -65,11 +65,11 @@ impl MonitorId {
         id: u32,
         repr: util::MonitorRepr,
         primary: bool,
-    ) -> Self {
-        let (name, hidpi_factor) = unsafe { xconn.get_output_info(resources, &repr) };
+    ) -> Option<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::AaRect::new(position, dimensions);
-        MonitorId {
+        Some(MonitorId {
             id,
             name,
             hidpi_factor,
@@ -77,7 +77,7 @@ impl MonitorId {
             position,
             primary,
             rect,
-        }
+        })
     }
 
     pub fn get_name(&self) -> Option<String> {
@@ -131,9 +131,14 @@ impl XConnection {
     fn query_monitor_list(&self) -> Vec<MonitorId> {
         unsafe {
             let root = (self.xlib.XDefaultRootWindow)(self.display);
-            // WARNING: this function is supposedly very slow, on the order of hundreds of ms.
-            // Upon failure, `resources` will be null.
-            let resources = (self.xrandr.XRRGetScreenResources)(self.display, root);
+            let resources = if version_is_at_least(1, 3) {
+                (self.xrandr.XRRGetScreenResourcesCurrent)(self.display, root)
+            } else {
+                // WARNING: this function is supposedly very slow, on the order of hundreds of ms.
+                // Upon failure, `resources` will be null.
+                (self.xrandr.XRRGetScreenResources)(self.display, root)
+            };
+
             if resources.is_null() {
                 panic!("[winit] `XRRGetScreenResources` returned NULL. That should only happen if the root window doesn't exist.");
             }
@@ -153,13 +158,13 @@ impl XConnection {
                     let monitor = monitors.offset(monitor_index as isize);
                     let is_primary = (*monitor).primary != 0;
                     has_primary |= is_primary;
-                    available.push(MonitorId::from_repr(
+                    MonitorId::from_repr(
                         self,
                         resources,
                         monitor_index as u32,
                         monitor.into(),
                         is_primary,
-                    ));
+                    ).map(|monitor_id| available.push(monitor_id));
                 }
                 (xrandr_1_5.XRRFreeMonitors)(monitors);
             } else {
@@ -176,13 +181,13 @@ impl XConnection {
                         let crtc = util::MonitorRepr::from(crtc);
                         let is_primary = crtc.get_output() == primary;
                         has_primary |= is_primary;
-                        available.push(MonitorId::from_repr(
+                        MonitorId::from_repr(
                             self,
                             resources,
                             crtc_id as u32,
                             crtc,
                             is_primary,
-                        ));
+                        ).map(|monitor_id| available.push(monitor_id));
                     }
                     (self.xrandr.XRRFreeCrtcInfo)(crtc);
                 }

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

@@ -24,6 +24,7 @@ impl From<bool> for StateOperation {
 /// X window type. Maps directly to
 /// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum WindowType {
     /// A desktop feature. This can include a single window containing desktop icons with the same dimensions as the
     /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxying

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

@@ -23,7 +23,7 @@ pub fn calc_dpi_factor(
     }
 
     // See http://xpra.org/trac/ticket/728 for more information.
-    if width_mm == 0 || width_mm == 0 {
+    if width_mm == 0 || height_mm == 0 {
         warn!("XRandR reported that the display's 0mm in size, which is certifiably insane");
         return 1.0;
     }
@@ -79,22 +79,56 @@ impl From<*mut ffi::XRRCrtcInfo> for MonitorRepr {
 }
 
 impl XConnection {
-    pub unsafe fn get_output_info(&self, resources: *mut ffi::XRRScreenResources, repr: &MonitorRepr) -> (String, f64) {
+    // Retrieve DPI from Xft.dpi property
+    pub unsafe fn get_xft_dpi(&self) -> Option<f64> {
+        (self.xlib.XrmInitialize)();
+        let resource_manager_str = (self.xlib.XResourceManagerString)(self.display);
+        if resource_manager_str == ptr::null_mut() {
+            return None;
+        }
+        if let Ok(res) = ::std::ffi::CStr::from_ptr(resource_manager_str).to_str() {
+            let name : &str = "Xft.dpi:\t";
+            for pair in res.split("\n") {
+                if pair.starts_with(&name) {
+                    let res = &pair[name.len()..];
+                    return f64::from_str(&res).ok();
+                }
+            }
+        }
+        None
+    }
+    pub unsafe fn get_output_info(
+        &self,
+        resources: *mut ffi::XRRScreenResources,
+        repr: &MonitorRepr,
+    ) -> Option<(String, f64)> {
         let output_info = (self.xrandr.XRRGetOutputInfo)(
             self.display,
             resources,
             repr.get_output(),
         );
+        if output_info.is_null() {
+            // When calling `XRRGetOutputInfo` on a virtual monitor (versus a physical display)
+            // it's possible for it to return null.
+            // https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=816596
+            let _ = self.check_errors(); // discard `BadRROutput` error
+            return None;
+        }
         let name_slice = slice::from_raw_parts(
             (*output_info).name as *mut u8,
             (*output_info).nameLen as usize,
         );
         let name = String::from_utf8_lossy(name_slice).into();
-        let hidpi_factor = calc_dpi_factor(
-            repr.get_dimensions(),
-            ((*output_info).mm_width as u64, (*output_info).mm_height as u64),
-        );
+        let hidpi_factor = if let Some(dpi) = self.get_xft_dpi() {
+            dpi / 96.
+        } else {
+            calc_dpi_factor(
+                repr.get_dimensions(),
+                ((*output_info).mm_width as u64, (*output_info).mm_height as u64),
+            )
+        };
+
         (self.xrandr.XRRFreeOutputInfo)(output_info);
-        (name, hidpi_factor)
+        Some((name, hidpi_factor))
     }
 }

src/platform/linux/x11/window.rs

@@ -1,3 +1,4 @@
+use raw_window_handle::unix::XlibHandle;
 use std::{cmp, env, mem};
 use std::ffi::CString;
 use std::os::raw::*;
@@ -37,6 +38,7 @@ pub struct SharedState {
     pub guessed_dpi: Option<f64>,
     pub last_monitor: Option<X11MonitorId>,
     pub dpi_adjusted: Option<(f64, f64)>,
+    pub fullscreen: Option<RootMonitorId>,
     // Used to restore position after exiting fullscreen.
     pub restore_position: Option<(i32, i32)>,
     pub frame_extents: Option<util::FrameExtentsHeuristic>,
@@ -278,8 +280,10 @@ impl UnownedWindow {
 
             // set size hints
             {
-                let mut min_dimensions = window_attrs.min_dimensions;
-                let mut max_dimensions = window_attrs.max_dimensions;
+                let mut min_dimensions = window_attrs.min_dimensions
+                    .map(|size| size.to_physical(dpi_factor));
+                let mut max_dimensions = window_attrs.max_dimensions
+                    .map(|size| size.to_physical(dpi_factor));
                 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");
@@ -531,8 +535,14 @@ impl UnownedWindow {
         }
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        self.shared_state.lock().fullscreen.clone()
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
+        self.shared_state.lock().fullscreen = monitor.clone();
         self.set_fullscreen_inner(monitor)
             .flush()
             .expect("Failed to change window fullscreen state");
@@ -1208,4 +1218,13 @@ impl UnownedWindow {
 
     #[inline]
     pub fn id(&self) -> WindowId { WindowId(self.xwindow) }
+
+    #[inline]
+    pub fn raw_window_handle(&self) -> XlibHandle {
+        XlibHandle {
+            window: self.xwindow,
+            display: self.xconn.display as _,
+            ..XlibHandle::empty()
+        }
+    }
 }

src/platform/linux/x11/xdisplay.rs

@@ -1,6 +1,7 @@
 use std::ptr;
 use std::fmt;
 use std::error::Error;
+use std::os::raw::c_int;
 
 use libc;
 use parking_lot::Mutex;
@@ -18,6 +19,7 @@ pub struct XConnection {
     pub xinput2: ffi::XInput2,
     pub xlib_xcb: ffi::Xlib_xcb,
     pub display: *mut ffi::Display,
+    pub x11_fd: c_int,
     pub latest_error: Mutex<Option<XError>>,
 }
 
@@ -48,6 +50,11 @@ impl XConnection {
             display
         };
 
+        // Get X11 socket file descriptor
+        let fd = unsafe {
+            (xlib.XConnectionNumber)(display)
+        };
+
         Ok(XConnection {
             xlib,
             xrandr,
@@ -56,6 +63,7 @@ impl XConnection {
             xinput2,
             xlib_xcb,
             display,
+            x11_fd: fd,
             latest_error: Mutex::new(None),
         })
     }

src/platform/macos/events_loop.rs

@@ -544,7 +544,67 @@ impl Proxy {
     }
 }
 
-pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
+pub fn char_to_keycode(c: char) -> Option<events::VirtualKeyCode> {
+    // We only translate keys that are affected by keyboard layout.
+    //
+    // Note that since keys are translated in a somewhat "dumb" way (reading character)
+    // there is a concern that some combination, i.e. Cmd+char, causes the wrong
+    // letter to be received, and so we receive the wrong key.
+    //
+    // Implementation reference: https://github.com/WebKit/webkit/blob/82bae82cf0f329dbe21059ef0986c4e92fea4ba6/Source/WebCore/platform/cocoa/KeyEventCocoa.mm#L626
+    Some(match c {
+        'a' | 'A' => events::VirtualKeyCode::A,
+        'b' | 'B' => events::VirtualKeyCode::B,
+        'c' | 'C' => events::VirtualKeyCode::C,
+        'd' | 'D' => events::VirtualKeyCode::D,
+        'e' | 'E' => events::VirtualKeyCode::E,
+        'f' | 'F' => events::VirtualKeyCode::F,
+        'g' | 'G' => events::VirtualKeyCode::G,
+        'h' | 'H' => events::VirtualKeyCode::H,
+        'i' | 'I' => events::VirtualKeyCode::I,
+        'j' | 'J' => events::VirtualKeyCode::J,
+        'k' | 'K' => events::VirtualKeyCode::K,
+        'l' | 'L' => events::VirtualKeyCode::L,
+        'm' | 'M' => events::VirtualKeyCode::M,
+        'n' | 'N' => events::VirtualKeyCode::N,
+        'o' | 'O' => events::VirtualKeyCode::O,
+        'p' | 'P' => events::VirtualKeyCode::P,
+        'q' | 'Q' => events::VirtualKeyCode::Q,
+        'r' | 'R' => events::VirtualKeyCode::R,
+        's' | 'S' => events::VirtualKeyCode::S,
+        't' | 'T' => events::VirtualKeyCode::T,
+        'u' | 'U' => events::VirtualKeyCode::U,
+        'v' | 'V' => events::VirtualKeyCode::V,
+        'w' | 'W' => events::VirtualKeyCode::W,
+        'x' | 'X' => events::VirtualKeyCode::X,
+        'y' | 'Y' => events::VirtualKeyCode::Y,
+        'z' | 'Z' => events::VirtualKeyCode::Z,
+        '1' | '!' => events::VirtualKeyCode::Key1,
+        '2' | '@' => events::VirtualKeyCode::Key2,
+        '3' | '#' => events::VirtualKeyCode::Key3,
+        '4' | '$' => events::VirtualKeyCode::Key4,
+        '5' | '%' => events::VirtualKeyCode::Key5,
+        '6' | '^' => events::VirtualKeyCode::Key6,
+        '7' | '&' => events::VirtualKeyCode::Key7,
+        '8' | '*' => events::VirtualKeyCode::Key8,
+        '9' | '(' => events::VirtualKeyCode::Key9,
+        '0' | ')' => events::VirtualKeyCode::Key0,
+        '=' | '+' => events::VirtualKeyCode::Equals,
+        '-' | '_' => events::VirtualKeyCode::Minus,
+        ']' | '}' => events::VirtualKeyCode::RBracket,
+        '[' | '{' => events::VirtualKeyCode::LBracket,
+        '\''| '"' => events::VirtualKeyCode::Apostrophe,
+        ';' | ':' => events::VirtualKeyCode::Semicolon,
+        '\\'| '|' => events::VirtualKeyCode::Backslash,
+        ',' | '<' => events::VirtualKeyCode::Comma,
+        '/' | '?' => events::VirtualKeyCode::Slash,
+        '.' | '>' => events::VirtualKeyCode::Period,
+        '`' | '~' => events::VirtualKeyCode::Grave,
+        _ => return None,
+    })
+}
+
+pub fn scancode_to_keycode(code: c_ushort) -> Option<events::VirtualKeyCode> {
     Some(match code {
         0x00 => events::VirtualKeyCode::A,
         0x01 => events::VirtualKeyCode::S,
@@ -600,8 +660,8 @@ pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
         0x33 => events::VirtualKeyCode::Back,
         //0x34 => unkown,
         0x35 => events::VirtualKeyCode::Escape,
-        0x36 => events::VirtualKeyCode::LWin,
-        0x37 => events::VirtualKeyCode::RWin,
+        0x36 => events::VirtualKeyCode::RWin,
+        0x37 => events::VirtualKeyCode::LWin,
         0x38 => events::VirtualKeyCode::LShift,
         //0x39 => Caps lock,
         0x3a => events::VirtualKeyCode::LAlt,
@@ -623,6 +683,7 @@ pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
         0x4a => events::VirtualKeyCode::VolumeDown,
         0x4b => events::VirtualKeyCode::Divide,
         0x4c => events::VirtualKeyCode::NumpadEnter,
+        0x4e => events::VirtualKeyCode::Subtract,
         //0x4d => unkown,
         0x4e => events::VirtualKeyCode::Subtract,
         0x4f => events::VirtualKeyCode::F18,
@@ -639,8 +700,8 @@ pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
         0x5a => events::VirtualKeyCode::F20,
         0x5b => events::VirtualKeyCode::Numpad8,
         0x5c => events::VirtualKeyCode::Numpad9,
-        //0x5d => unkown,
-        //0x5e => unkown,
+        0x5d => events::VirtualKeyCode::Yen,
+        //0x5e => JIS Ro,
         //0x5f => unkown,
         0x60 => events::VirtualKeyCode::F5,
         0x61 => events::VirtualKeyCode::F6,
@@ -648,9 +709,9 @@ pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
         0x63 => events::VirtualKeyCode::F3,
         0x64 => events::VirtualKeyCode::F8,
         0x65 => events::VirtualKeyCode::F9,
-        //0x66 => unkown,
+        //0x66 => JIS Eisuu (macOS),
         0x67 => events::VirtualKeyCode::F11,
-        //0x68 => unkown,
+        //0x68 => JIS Kana (macOS),
         0x69 => events::VirtualKeyCode::F13,
         0x6a => events::VirtualKeyCode::F16,
         0x6b => events::VirtualKeyCode::F14,
@@ -680,20 +741,19 @@ pub fn to_virtual_key_code(code: c_ushort) -> Option<events::VirtualKeyCode> {
     })
 }
 
-pub fn check_additional_virtual_key_codes(
-    s: &Option<String>
+pub fn check_function_keys(
+    s: &String
 ) -> Option<events::VirtualKeyCode> {
-    if let &Some(ref s) = s {
-        if let Some(ch) = s.encode_utf16().next() {
-            return Some(match ch {
-                0xf718 => events::VirtualKeyCode::F21,
-                0xf719 => events::VirtualKeyCode::F22,
-                0xf71a => events::VirtualKeyCode::F23,
-                0xf71b => events::VirtualKeyCode::F24,
-                _ => return None,
-            })
-        }
+    if let Some(ch) = s.encode_utf16().next() {
+        return Some(match ch {
+            0xf718 => events::VirtualKeyCode::F21,
+            0xf719 => events::VirtualKeyCode::F22,
+            0xf71a => events::VirtualKeyCode::F23,
+            0xf71b => events::VirtualKeyCode::F24,
+            _ => return None,
+        })
     }
+
     None
 }
 
@@ -709,6 +769,16 @@ pub fn event_mods(event: cocoa::base::id) -> ModifiersState {
     }
 }
 
+pub fn get_scancode(event: cocoa::base::id) -> c_ushort {
+    // In AppKit, `keyCode` refers to the position (scancode) of a key rather than its character,
+    // and there is no easy way to navtively retrieve the layout-dependent character.
+    // In winit, we use keycode to refer to the key's character, and so this function aligns
+    // AppKit's terminology with ours.
+    unsafe {
+        msg_send![event, keyCode]
+    }
+}
+
 unsafe fn modifier_event(
     ns_event: cocoa::base::id,
     keymask: NSEventModifierFlags,
@@ -721,14 +791,14 @@ unsafe fn modifier_event(
         } else {
             ElementState::Pressed
         };
-        let keycode = NSEvent::keyCode(ns_event);
-        let scancode = keycode as u32;
-        let virtual_keycode = to_virtual_key_code(keycode);
+
+        let scancode = get_scancode(ns_event);
+        let virtual_keycode = scancode_to_keycode(scancode);
         Some(WindowEvent::KeyboardInput {
             device_id: DEVICE_ID,
             input: KeyboardInput {
                 state,
-                scancode,
+                scancode: scancode as u32,
                 virtual_keycode,
                 modifiers: event_mods(ns_event),
             },

src/platform/macos/mod.rs

@@ -8,6 +8,12 @@ use std::sync::Arc;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId
+    }
+}
+
 use {CreationError};
 
 pub struct Window {

src/platform/macos/util/cursor.rs

@@ -0,0 +1,149 @@
+use cocoa::{
+    appkit::NSImage, base::{id, nil, YES},
+    foundation::{NSDictionary, NSPoint, NSString},
+};
+use objc::runtime::Sel;
+
+use super::IntoOption;
+use MouseCursor;
+
+pub enum Cursor {
+    Native(&'static str),
+    Undocumented(&'static str),
+    WebKit(&'static str),
+}
+
+impl From<MouseCursor> for Cursor {
+    fn from(cursor: MouseCursor) -> Self {
+        match cursor {
+            MouseCursor::Arrow | MouseCursor::Default => Cursor::Native("arrowCursor"),
+            MouseCursor::Hand => Cursor::Native("pointingHandCursor"),
+            MouseCursor::Grabbing | MouseCursor::Grab => Cursor::Native("closedHandCursor"),
+            MouseCursor::Text => Cursor::Native("IBeamCursor"),
+            MouseCursor::VerticalText => Cursor::Native("IBeamCursorForVerticalLayout"),
+            MouseCursor::Copy => Cursor::Native("dragCopyCursor"),
+            MouseCursor::Alias => Cursor::Native("dragLinkCursor"),
+            MouseCursor::NotAllowed | MouseCursor::NoDrop => Cursor::Native("operationNotAllowedCursor"),
+            MouseCursor::ContextMenu => Cursor::Native("contextualMenuCursor"),
+            MouseCursor::Crosshair => Cursor::Native("crosshairCursor"),
+            MouseCursor::EResize => Cursor::Native("resizeRightCursor"),
+            MouseCursor::NResize => Cursor::Native("resizeUpCursor"),
+            MouseCursor::WResize => Cursor::Native("resizeLeftCursor"),
+            MouseCursor::SResize => Cursor::Native("resizeDownCursor"),
+            MouseCursor::EwResize | MouseCursor::ColResize => Cursor::Native("resizeLeftRightCursor"),
+            MouseCursor::NsResize | MouseCursor::RowResize => Cursor::Native("resizeUpDownCursor"),
+
+            // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
+            MouseCursor::Help => Cursor::Undocumented("_helpCursor"),
+            MouseCursor::ZoomIn => Cursor::Undocumented("_zoomInCursor"),
+            MouseCursor::ZoomOut => Cursor::Undocumented("_zoomOutCursor"),
+            MouseCursor::NeResize => Cursor::Undocumented("_windowResizeNorthEastCursor"),
+            MouseCursor::NwResize => Cursor::Undocumented("_windowResizeNorthWestCursor"),
+            MouseCursor::SeResize => Cursor::Undocumented("_windowResizeSouthEastCursor"),
+            MouseCursor::SwResize => Cursor::Undocumented("_windowResizeSouthWestCursor"),
+            MouseCursor::NeswResize => Cursor::Undocumented("_windowResizeNorthEastSouthWestCursor"),
+            MouseCursor::NwseResize => Cursor::Undocumented("_windowResizeNorthWestSouthEastCursor"),
+
+            // While these are available, the former just loads a white arrow,
+            // and the latter loads an ugly deflated beachball!
+            // MouseCursor::Move => Cursor::Undocumented("_moveCursor"),
+            // MouseCursor::Wait => Cursor::Undocumented("_waitCursor"),
+
+            // An even more undocumented cursor...
+            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
+            // This is the wrong semantics for `Wait`, but it's the same as
+            // what's used in Safari and Chrome.
+            MouseCursor::Wait | MouseCursor::Progress => Cursor::Undocumented("busyButClickableCursor"),
+
+            // For the rest, we can just snatch the cursors from WebKit...
+            // They fit the style of the native cursors, and will seem
+            // completely standard to macOS users.
+            // https://stackoverflow.com/a/21786835/5435443
+            MouseCursor::Move | MouseCursor::AllScroll => Cursor::WebKit("move"),
+            MouseCursor::Cell => Cursor::WebKit("cell"),
+        }
+    }
+}
+
+impl Default for Cursor {
+    fn default() -> Self {
+        Cursor::Native("arrowCursor")
+    }
+}
+
+impl Cursor {
+    pub unsafe fn load(&self) -> id {
+        match self {
+            Cursor::Native(cursor_name) => {
+                let sel = Sel::register(cursor_name);
+                msg_send![class!(NSCursor), performSelector:sel]
+            },
+            Cursor::Undocumented(cursor_name) => {
+                let class = class!(NSCursor);
+                let sel = Sel::register(cursor_name);
+                let sel = if msg_send![class, respondsToSelector:sel] {
+                    sel
+                } else {
+                    warn!("Cursor `{}` appears to be invalid", cursor_name);
+                    sel!(arrowCursor)
+                };
+                msg_send![class, performSelector:sel]
+            },
+            Cursor::WebKit(cursor_name) => load_webkit_cursor(cursor_name)
+                .unwrap_or_else(|message| {
+                    warn!("{}", message);
+                    Self::default().load()
+                }),
+        }
+    }
+}
+
+// Note that loading `busybutclickable` with this code won't animate the frames;
+// instead you'll just get them all in a column.
+unsafe fn load_webkit_cursor(cursor_name_str: &str) -> Result<id, String> {
+    static CURSOR_ROOT: &'static str = "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/HIServices.framework/Versions/A/Resources/cursors";
+    let cursor_root = NSString::alloc(nil).init_str(CURSOR_ROOT);
+    let cursor_name = NSString::alloc(nil).init_str(cursor_name_str);
+    let cursor_pdf = NSString::alloc(nil).init_str("cursor.pdf");
+    let cursor_plist = NSString::alloc(nil).init_str("info.plist");
+    let key_x = NSString::alloc(nil).init_str("hotx");
+    let key_y = NSString::alloc(nil).init_str("hoty");
+
+    let cursor_path: id = msg_send![cursor_root,
+        stringByAppendingPathComponent:cursor_name
+    ];
+    let pdf_path: id = msg_send![cursor_path,
+        stringByAppendingPathComponent:cursor_pdf
+    ];
+    let info_path: id = msg_send![cursor_path,
+        stringByAppendingPathComponent:cursor_plist
+    ];
+
+    let image = NSImage::alloc(nil)
+        .initByReferencingFile_(pdf_path)
+        // This will probably never be `None`, since images are loaded lazily...
+        .into_option()
+        // because of that, we need to check for validity.
+        .filter(|image| image.isValid() == YES)
+        .ok_or_else(||
+            format!("Failed to read image for `{}` cursor", cursor_name_str)
+        )?;
+    let info = NSDictionary::dictionaryWithContentsOfFile_(nil, info_path)
+        .into_option()
+        .ok_or_else(||
+            format!("Failed to read info for `{}` cursor", cursor_name_str)
+        )?;
+    let x = info.valueForKey_(key_x);
+    let y = info.valueForKey_(key_y);
+    let point = NSPoint::new(
+        msg_send![x, doubleValue],
+        msg_send![y, doubleValue],
+    );
+    let cursor: id = msg_send![class!(NSCursor), alloc];
+    let cursor: id = msg_send![cursor, initWithImage:image hotSpot:point];
+    cursor
+        .into_option()
+        .ok_or_else(||
+            format!("Failed to initialize `{}` cursor", cursor_name_str)
+        )
+}

src/platform/macos/util/into_option.rs

@@ -0,0 +1,14 @@
+use cocoa::base::{id, nil};
+
+pub trait IntoOption: Sized {
+    fn into_option(self) -> Option<Self>;
+}
+
+impl IntoOption for id {
+    fn into_option(self) -> Option<Self> {
+        match self != nil {
+            true => Some(self),
+            false => None,
+        }
+    }
+}

src/platform/macos/util/mod.rs

@@ -1,7 +1,13 @@
+mod cursor;
+mod into_option;
+
+pub use self::{cursor::Cursor, into_option::IntoOption};
+
 use cocoa::appkit::NSWindowStyleMask;
 use cocoa::base::{id, nil};
 use cocoa::foundation::{NSRect, NSUInteger};
 use core_graphics::display::CGDisplay;
+use objc::runtime::{Class, Object};
 
 use platform::platform::ffi;
 use platform::platform::window::IdRef;
@@ -25,6 +31,25 @@ pub unsafe fn set_style_mask(window: id, view: id, mask: NSWindowStyleMask) {
     window.makeFirstResponder_(view);
 }
 
+pub unsafe fn toggle_style_mask(window: id, view: id, mask: NSWindowStyleMask, on: bool) {
+    use cocoa::appkit::NSWindow;
+
+    let current_style_mask = window.styleMask();
+    if on {
+        window.setStyleMask_(current_style_mask | mask);
+    } else {
+        window.setStyleMask_(current_style_mask & (!mask));
+    }
+
+    // If we don't do this, key handling will break. Therefore, never call `setStyleMask` directly!
+    window.makeFirstResponder_(view);
+}
+
+pub unsafe fn superclass<'a>(this: &'a Object) -> &'a Class {
+    let superclass: id = msg_send![this, superclass];
+    &*(superclass as *const _)
+}
+
 pub unsafe fn create_input_context(view: id) -> IdRef {
     let input_context: id = msg_send![class!(NSTextInputContext), alloc];
     let input_context: id = msg_send![input_context, initWithClient:view];

src/platform/macos/view.rs

@@ -5,7 +5,7 @@ use std::{slice, str};
 use std::boxed::Box;
 use std::collections::VecDeque;
 use std::os::raw::*;
-use std::sync::Weak;
+use std::sync::{Arc, Mutex, Weak};
 
 use cocoa::base::{id, nil};
 use cocoa::appkit::{NSEvent, NSView, NSWindow};
@@ -14,23 +14,28 @@ use objc::declare::ClassDecl;
 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, check_additional_virtual_key_codes};
+use platform::platform::events_loop::{DEVICE_ID, event_mods, Shared, scancode_to_keycode, char_to_keycode, check_function_keys, get_scancode};
 use platform::platform::util;
 use platform::platform::ffi::*;
 use platform::platform::window::{get_window_id, IdRef};
+use events;
 
 struct ViewState {
     window: id,
     shared: Weak<Shared>,
+    cursor: Arc<Mutex<util::Cursor>>,
     ime_spot: Option<(f64, f64)>,
     raw_characters: Option<String>,
     is_key_down: bool,
 }
 
-pub fn new_view(window: id, shared: Weak<Shared>) -> IdRef {
+pub fn new_view(window: id, shared: Weak<Shared>) -> (IdRef, Weak<Mutex<util::Cursor>>) {
+    let cursor = Default::default();
+    let cursor_access = Arc::downgrade(&cursor);
     let state = ViewState {
         window,
         shared,
+        cursor,
         ime_spot: None,
         raw_characters: None,
         is_key_down: false,
@@ -39,7 +44,7 @@ pub fn new_view(window: id, shared: Weak<Shared>) -> IdRef {
         // This is free'd in `dealloc`
         let state_ptr = Box::into_raw(Box::new(state)) as *mut c_void;
         let view: id = msg_send![VIEW_CLASS.0, alloc];
-        IdRef::new(msg_send![view, initWithWinit:state_ptr])
+        (IdRef::new(msg_send![view, initWithWinit:state_ptr]), cursor_access)
     }
 }
 
@@ -71,6 +76,14 @@ lazy_static! {
             sel!(initWithWinit:),
             init_with_winit as extern fn(&Object, Sel, *mut c_void) -> id,
         );
+        decl.add_method(
+            sel!(drawRect:),
+            draw_rect as extern fn(&Object, Sel, NSRect),
+        );
+        decl.add_method(
+            sel!(resetCursorRects),
+            reset_cursor_rects as extern fn(&Object, Sel),
+        );
         decl.add_method(sel!(hasMarkedText), has_marked_text as extern fn(&Object, Sel) -> BOOL);
         decl.add_method(
             sel!(markedRange),
@@ -154,6 +167,41 @@ extern fn init_with_winit(this: &Object, _sel: Sel, state: *mut c_void) -> id {
     }
 }
 
+extern fn draw_rect(this: &Object, _sel: Sel, rect: NSRect) {
+    unsafe {
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+
+        if let Some(shared) = state.shared.upgrade() {
+            let window_event = Event::WindowEvent {
+                window_id: WindowId(get_window_id(state.window)),
+                event: WindowEvent::Refresh,
+            };
+            shared.pending_events
+                .lock()
+                .unwrap()
+                .push_back(window_event);
+        }
+
+        let superclass = util::superclass(this);
+        let () = msg_send![super(this, superclass), drawRect:rect];
+    }
+}
+
+extern fn reset_cursor_rects(this: &Object, _sel: Sel) {
+    unsafe {
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+
+        let bounds: NSRect = msg_send![this, bounds];
+        let cursor = state.cursor.lock().unwrap().load();
+        let _: () = msg_send![this,
+            addCursorRect:bounds
+            cursor:cursor
+        ];
+    }
+}
+
 extern fn has_marked_text(this: &Object, _sel: Sel) -> BOOL {
     //println!("hasMarkedText");
     unsafe {
@@ -344,36 +392,68 @@ extern fn do_command_by_selector(this: &Object, _sel: Sel, command: Sel) {
     }
 }
 
-fn get_characters(event: id) -> Option<String> {
+fn get_characters(event: id, ignore_modifiers: bool) -> String {
     unsafe {
-        let characters: id = msg_send![event, characters];
+        let characters: id = if ignore_modifiers {
+            msg_send![event, charactersIgnoringModifiers]
+        } else {
+            msg_send![event, characters]
+        };
+
+        assert_ne!(characters, nil);
         let slice = slice::from_raw_parts(
             characters.UTF8String() as *const c_uchar,
             characters.len(),
         );
+
         let string = str::from_utf8_unchecked(slice);
-        Some(string.to_owned())
+
+        string.to_owned()
     }
 }
 
+// Retrieves a layout-independent keycode given an event.
+fn retrieve_keycode(event: id) -> Option<events::VirtualKeyCode> {
+    #[inline]
+    fn get_code(ev: id, raw: bool) -> Option<events::VirtualKeyCode> {
+        let characters = get_characters(ev, raw);
+        characters.chars().next().map_or(None, |c| char_to_keycode(c))
+    }
+
+    // Cmd switches Roman letters for Dvorak-QWERTY layout, so we try modified characters first.
+    // If we don't get a match, then we fall back to unmodified characters.
+    let code = get_code(event, false)
+        .or_else(|| {
+            get_code(event, true)
+        });
+
+    // We've checked all layout related keys, so fall through to scancode.
+    // Reaching this code means that the key is layout-independent (e.g. Backspace, Return).
+    //
+    // We're additionally checking here for F21-F24 keys, since their keycode
+    // can vary, but we know that they are encoded
+    // in characters property.
+    code.or_else(|| {
+        let scancode = get_scancode(event);
+        scancode_to_keycode(scancode)
+            .or_else(|| {
+                check_function_keys(&get_characters(event, true))
+            })
+    })
+}
+
 extern fn key_down(this: &Object, _sel: Sel, event: id) {
     //println!("keyDown");
     unsafe {
         let state_ptr: *mut c_void = *this.get_ivar("winitState");
         let state = &mut *(state_ptr as *mut ViewState);
         let window_id = WindowId(get_window_id(state.window));
+        let characters = get_characters(event, false);
 
-        state.raw_characters = get_characters(event);
+        state.raw_characters = Some(characters.clone());
 
-        let keycode: c_ushort = msg_send![event, keyCode];
-        // We are checking here for F21-F24 keys, since their keycode
-        // can vary, but we know that they are encoded
-        // in characters property.
-        let virtual_keycode = to_virtual_key_code(keycode)
-            .or_else(|| {
-                check_additional_virtual_key_codes(&state.raw_characters)
-            });
-        let scancode = keycode as u32;
+        let scancode = get_scancode(event) as u32;
+        let virtual_keycode = retrieve_keycode(event);
         let is_repeat = msg_send![event, isARepeat];
 
         let window_event = Event::WindowEvent {
@@ -389,17 +469,6 @@ extern fn key_down(this: &Object, _sel: Sel, event: id) {
             },
         };
 
-        let characters: id = msg_send![event, characters];
-        let slice = slice::from_raw_parts(
-            characters.UTF8String() as *const c_uchar,
-            characters.len(),
-            );
-        let string = str::from_utf8_unchecked(slice);
-
-        state.raw_characters = {
-            Some(string.to_owned())
-        };
-
         if let Some(shared) = state.shared.upgrade() {
             shared.pending_events
                 .lock()
@@ -407,7 +476,7 @@ extern fn key_down(this: &Object, _sel: Sel, event: id) {
                 .push_back(window_event);
             // Emit `ReceivedCharacter` for key repeats
             if is_repeat && state.is_key_down{
-                for character in string.chars() {
+                for character in characters.chars() {
                     let window_event = Event::WindowEvent {
                         window_id,
                         event: WindowEvent::ReceivedCharacter(character),
@@ -436,16 +505,9 @@ extern fn key_up(this: &Object, _sel: Sel, event: id) {
 
         state.is_key_down = false;
 
-        // We need characters here to check for additional keys such as
-        // F21-F24.
-        let characters = get_characters(event);
+        let scancode = get_scancode(event) as u32;
+        let virtual_keycode = retrieve_keycode(event);
 
-        let keycode: c_ushort = msg_send![event, keyCode];
-        let virtual_keycode = to_virtual_key_code(keycode)
-            .or_else(|| {
-                check_additional_virtual_key_codes(&characters)
-            });
-        let scancode = keycode as u32;
         let window_event = Event::WindowEvent {
             window_id: WindowId(get_window_id(state.window)),
             event: WindowEvent::KeyboardInput {

src/platform/macos/window.rs

@@ -1,9 +1,10 @@
+use raw_window_handle::{macos::MacOSHandle, RawWindowHandle};
 use std;
 use std::cell::{Cell, RefCell};
 use std::f64;
 use std::ops::Deref;
 use std::os::raw::c_void;
-use std::sync::Weak;
+use std::sync::{Mutex, Weak};
 use std::sync::atomic::{Ordering, AtomicBool};
 
 use cocoa::appkit::{
@@ -19,6 +20,7 @@ use cocoa::appkit::{
     NSWindowButton,
     NSWindowStyleMask,
     NSApplicationActivationPolicy,
+    NSApplicationPresentationOptions,
 };
 use cocoa::base::{id, nil};
 use cocoa::foundation::{NSAutoreleasePool, NSDictionary, NSPoint, NSRect, NSSize, NSString};
@@ -49,6 +51,12 @@ use window::MonitorId as RootMonitorId;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Id(pub usize);
 
+impl Id {
+    pub unsafe fn dummy() -> Self {
+        Id(0)
+    }
+}
+
 // TODO: It's possible for delegate methods to be called asynchronously, causing data races / `RefCell` panics.
 pub struct DelegateState {
     view: IdRef,
@@ -57,7 +65,9 @@ pub struct DelegateState {
 
     win_attribs: RefCell<WindowAttributes>,
     standard_frame: Cell<Option<NSRect>>,
+    is_simple_fullscreen: Cell<bool>,
     save_style_mask: Cell<Option<NSWindowStyleMask>>,
+    save_presentation_opts: Cell<Option<NSApplicationPresentationOptions>>,
 
     // This is set when WindowBuilder::with_fullscreen was set,
     // see comments of `window_did_fail_to_enter_fullscreen`
@@ -94,22 +104,30 @@ impl DelegateState {
         }
     }
 
+    unsafe fn saved_style_mask(&self, resizable: bool) -> NSWindowStyleMask {
+        let base_mask = self.save_style_mask
+            .take()
+            .unwrap_or_else(|| self.window.styleMask());
+        if resizable {
+            base_mask | NSWindowStyleMask::NSResizableWindowMask
+        } else {
+            base_mask & !NSWindowStyleMask::NSResizableWindowMask
+        }
+    }
+
+    fn saved_standard_frame(&self) -> NSRect {
+        self.standard_frame.get().unwrap_or_else(|| NSRect::new(
+            NSPoint::new(50.0, 50.0),
+            NSSize::new(800.0, 600.0),
+        ))
+    }
+
     fn restore_state_from_fullscreen(&mut self) {
         let maximized = unsafe {
             let mut win_attribs = self.win_attribs.borrow_mut();
             win_attribs.fullscreen = None;
 
-            let mask = {
-                let base_mask = self.save_style_mask
-                    .take()
-                    .unwrap_or_else(|| self.window.styleMask());
-                if win_attribs.resizable {
-                    base_mask | NSWindowStyleMask::NSResizableWindowMask
-                } else {
-                    base_mask & !NSWindowStyleMask::NSResizableWindowMask
-                }
-            };
-
+            let mask = self.saved_style_mask(win_attribs.resizable);
             util::set_style_mask(*self.window, *self.view, mask);
 
             win_attribs.maximized
@@ -151,10 +169,7 @@ impl DelegateState {
                     let screen = NSScreen::mainScreen(nil);
                     NSScreen::visibleFrame(screen)
                 } else {
-                    self.standard_frame.get().unwrap_or(NSRect::new(
-                        NSPoint::new(50.0, 50.0),
-                        NSSize::new(800.0, 600.0),
-                    ))
+                    self.saved_standard_frame()
                 };
 
                 self.window.setFrame_display_(new_rect, 0);
@@ -316,7 +331,9 @@ impl WindowDelegate {
         }
 
         /// Invoked when the image is released
-        extern fn prepare_for_drag_operation(_: &Object, _: Sel, _: id) {}
+        extern fn prepare_for_drag_operation(_: &Object, _: Sel, _: id) -> BOOL {
+            YES
+        }
 
         /// Invoked after the released image has been removed from the screen
         extern fn perform_drag_operation(this: &Object, _: Sel, sender: id) -> BOOL {
@@ -451,7 +468,7 @@ impl WindowDelegate {
             decl.add_method(sel!(draggingEntered:),
                 dragging_entered as extern fn(&Object, Sel, id) -> BOOL);
             decl.add_method(sel!(prepareForDragOperation:),
-                prepare_for_drag_operation as extern fn(&Object, Sel, id));
+                prepare_for_drag_operation as extern fn(&Object, Sel, id) -> BOOL);
             decl.add_method(sel!(performDragOperation:),
                 perform_drag_operation as extern fn(&Object, Sel, id) -> BOOL);
             decl.add_method(sel!(concludeDragOperation:),
@@ -531,6 +548,7 @@ pub struct Window2 {
     pub window: IdRef,
     pub delegate: WindowDelegate,
     pub input_context: IdRef,
+    cursor: Weak<Mutex<util::Cursor>>,
     cursor_hidden: AtomicBool,
 }
 
@@ -600,6 +618,73 @@ impl WindowExt for Window2 {
             NSApp().requestUserAttention_(request_type);
         }
     }
+
+    #[inline]
+    fn get_simple_fullscreen(&self) -> bool {
+        self.delegate.state.is_simple_fullscreen.get()
+    }
+
+    #[inline]
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
+        let state = &self.delegate.state;
+
+        unsafe {
+            let app = NSApp();
+            let win_attribs = state.win_attribs.borrow_mut();
+            let is_native_fullscreen = win_attribs.fullscreen.is_some();
+            let is_simple_fullscreen = state.is_simple_fullscreen.get();
+
+            // Do nothing if native fullscreen is active.
+            if is_native_fullscreen || (fullscreen && is_simple_fullscreen) || (!fullscreen && !is_simple_fullscreen) {
+                return false;
+            }
+
+            if fullscreen {
+                // Remember the original window's settings
+                state.standard_frame.set(Some(NSWindow::frame(*self.window)));
+                state.save_style_mask.set(Some(self.window.styleMask()));
+                state.save_presentation_opts.set(Some(app.presentationOptions_()));
+
+                // Tell our window's state that we're in fullscreen
+                state.is_simple_fullscreen.set(true);
+
+                // Simulate pre-Lion fullscreen by hiding the dock and menu bar
+                let presentation_options =
+                    NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock |
+                    NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar;
+                app.setPresentationOptions_(presentation_options);
+
+                // Hide the titlebar
+                util::toggle_style_mask(*self.window, *self.view, NSWindowStyleMask::NSTitledWindowMask, false);
+
+                // Set the window frame to the screen frame size
+                let screen = self.window.screen();
+                let screen_frame = NSScreen::frame(screen);
+                NSWindow::setFrame_display_(*self.window, screen_frame, YES);
+
+                // Fullscreen windows can't be resized, minimized, or moved
+                util::toggle_style_mask(*self.window, *self.view, NSWindowStyleMask::NSMiniaturizableWindowMask, false);
+                util::toggle_style_mask(*self.window, *self.view, NSWindowStyleMask::NSResizableWindowMask, false);
+                NSWindow::setMovable_(*self.window, NO);
+
+                true
+            } else {
+                let saved_style_mask = state.saved_style_mask(win_attribs.resizable);
+                util::set_style_mask(*self.window, *self.view, saved_style_mask);
+                state.is_simple_fullscreen.set(false);
+
+                if let Some(presentation_opts) = state.save_presentation_opts.get() {
+                    app.setPresentationOptions_(presentation_opts);
+                }
+
+                let frame = state.saved_standard_frame();
+                NSWindow::setFrame_display_(*self.window, frame, YES);
+                NSWindow::setMovable_(*self.window, YES);
+
+                true
+            }
+        }
+    }
 }
 
 impl Window2 {
@@ -636,7 +721,7 @@ impl Window2 {
                 return Err(OsError(format!("Couldn't create NSWindow")));
             },
         };
-        let view = match Window2::create_view(*window, Weak::clone(&shared)) {
+        let (view, cursor) = match Window2::create_view(*window, Weak::clone(&shared)) {
             Some(view) => view,
             None => {
                 let _: () = unsafe { msg_send![autoreleasepool, drain] };
@@ -675,7 +760,9 @@ impl Window2 {
             shared,
             win_attribs: RefCell::new(win_attribs.clone()),
             standard_frame: Cell::new(None),
+            is_simple_fullscreen: Cell::new(false),
             save_style_mask: Cell::new(None),
+            save_presentation_opts: Cell::new(None),
             handle_with_fullscreen: win_attribs.fullscreen.is_some(),
             previous_position: None,
             previous_dpi_factor: dpi_factor,
@@ -692,6 +779,7 @@ impl Window2 {
             window: window,
             delegate: WindowDelegate::new(delegate_state),
             input_context,
+            cursor,
             cursor_hidden: Default::default(),
         };
 
@@ -870,9 +958,9 @@ impl Window2 {
         }
     }
 
-    fn create_view(window: id, shared: Weak<Shared>) -> Option<IdRef> {
+    fn create_view(window: id, shared: Weak<Shared>) -> Option<(IdRef, Weak<Mutex<util::Cursor>>)> {
         unsafe {
-            let view = new_view(window, shared);
+            let (view, cursor) = new_view(window, shared);
             view.non_nil().map(|view| {
                 view.setWantsBestResolutionOpenGLSurface_(YES);
 
@@ -887,7 +975,7 @@ impl Window2 {
 
                 window.setContentView_(*view);
                 window.makeFirstResponder_(*view);
-                view
+                (view, cursor)
             })
         }
     }
@@ -994,40 +1082,14 @@ impl Window2 {
     }
 
     pub fn set_cursor(&self, cursor: MouseCursor) {
-        let cursor_name = match cursor {
-            MouseCursor::Arrow | MouseCursor::Default => "arrowCursor",
-            MouseCursor::Hand => "pointingHandCursor",
-            MouseCursor::Grabbing | MouseCursor::Grab => "closedHandCursor",
-            MouseCursor::Text => "IBeamCursor",
-            MouseCursor::VerticalText => "IBeamCursorForVerticalLayout",
-            MouseCursor::Copy => "dragCopyCursor",
-            MouseCursor::Alias => "dragLinkCursor",
-            MouseCursor::NotAllowed | MouseCursor::NoDrop => "operationNotAllowedCursor",
-            MouseCursor::ContextMenu => "contextualMenuCursor",
-            MouseCursor::Crosshair => "crosshairCursor",
-            MouseCursor::EResize => "resizeRightCursor",
-            MouseCursor::NResize => "resizeUpCursor",
-            MouseCursor::WResize => "resizeLeftCursor",
-            MouseCursor::SResize => "resizeDownCursor",
-            MouseCursor::EwResize | MouseCursor::ColResize => "resizeLeftRightCursor",
-            MouseCursor::NsResize | MouseCursor::RowResize => "resizeUpDownCursor",
-
-            // TODO: Find appropriate OSX cursors
-            MouseCursor::NeResize | MouseCursor::NwResize |
-            MouseCursor::SeResize | MouseCursor::SwResize |
-            MouseCursor::NwseResize | MouseCursor::NeswResize |
-
-            MouseCursor::Cell |
-            MouseCursor::Wait | MouseCursor::Progress | MouseCursor::Help |
-            MouseCursor::Move | MouseCursor::AllScroll | MouseCursor::ZoomIn |
-            MouseCursor::ZoomOut => "arrowCursor",
-        };
-        let sel = Sel::register(cursor_name);
-        let cls = class!(NSCursor);
+        let cursor = util::Cursor::from(cursor);
+        if let Some(cursor_access) = self.cursor.upgrade() {
+            *cursor_access.lock().unwrap() = cursor;
+        }
         unsafe {
-            use objc::Message;
-            let cursor: id = cls.send_message(sel, ()).unwrap();
-            let _: () = msg_send![cursor, set];
+            let _: () = msg_send![*self.window,
+                invalidateCursorRectsForView:*self.view
+            ];
         }
     }
 
@@ -1081,11 +1143,25 @@ impl Window2 {
         self.delegate.state.perform_maximized(maximized)
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        let state = &self.delegate.state;
+        let win_attribs = state.win_attribs.borrow();
+
+        win_attribs.fullscreen.clone()
+    }
+
     #[inline]
     /// TODO: Right now set_fullscreen do not work on switching monitors
     /// in fullscreen mode
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
         let state = &self.delegate.state;
+
+        // Do nothing if simple fullscreen is active.
+        if state.is_simple_fullscreen.get() {
+            return
+        }
+
         let current = {
             let win_attribs = state.win_attribs.borrow_mut();
 
@@ -1191,6 +1267,16 @@ impl Window2 {
             self::get_current_monitor(*self.window)
         }
     }
+
+    #[inline]
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let handle = MacOSHandle {
+            ns_window: self.get_nswindow(),
+            ns_view: self.get_nsview(),
+            ..MacOSHandle::empty()
+        };
+        RawWindowHandle::MacOS(handle)
+    }
 }
 
 // Convert the `cocoa::base::id` associated with a window to a usize to use as a unique identifier

src/platform/windows/drop_handler.rs

@@ -10,7 +10,7 @@ use winapi::shared::minwindef::{DWORD, MAX_PATH, UINT, ULONG};
 use winapi::shared::windef::{HWND, POINTL};
 use winapi::shared::winerror::S_OK;
 use winapi::um::objidl::IDataObject;
-use winapi::um::oleidl::{IDropTarget, IDropTargetVtbl};
+use winapi::um::oleidl::{DROPEFFECT_COPY, DROPEFFECT_NONE, IDropTarget, IDropTargetVtbl};
 use winapi::um::winnt::HRESULT;
 use winapi::um::{shellapi, unknwnbase};
 
@@ -24,6 +24,8 @@ pub struct FileDropHandlerData {
     pub interface: IDropTarget,
     refcount: AtomicUsize,
     window: HWND,
+    cursor_effect: DWORD,
+    hovered_is_valid: bool, // If the currently hovered item is not valid there must not be any `HoveredFileCancelled` emitted
 }
 
 pub struct FileDropHandler {
@@ -39,6 +41,8 @@ impl FileDropHandler {
             },
             refcount: AtomicUsize::new(1),
             window,
+            cursor_effect: DROPEFFECT_NONE,
+            hovered_is_valid: false,
         });
         FileDropHandler {
             data: Box::into_raw(data),
@@ -77,36 +81,48 @@ impl FileDropHandler {
         pDataObj: *const IDataObject,
         _grfKeyState: DWORD,
         _pt: *const POINTL,
-        _pdwEffect: *mut DWORD,
+        pdwEffect: *mut DWORD,
     ) -> HRESULT {
         use events::WindowEvent::HoveredFile;
         let drop_handler = Self::from_interface(this);
-        Self::iterate_filenames(pDataObj, |filename| {
+        let hdrop = Self::iterate_filenames(pDataObj, |filename| {
             send_event(Event::WindowEvent {
                 window_id: SuperWindowId(WindowId(drop_handler.window)),
                 event: HoveredFile(filename),
             });
         });
+        drop_handler.hovered_is_valid = hdrop.is_some();
+        drop_handler.cursor_effect = if drop_handler.hovered_is_valid {
+            DROPEFFECT_COPY
+        } else {
+            DROPEFFECT_NONE
+        };
+        *pdwEffect = drop_handler.cursor_effect;
 
         S_OK
     }
 
     pub unsafe extern "system" fn DragOver(
-        _this: *mut IDropTarget,
+        this: *mut IDropTarget,
         _grfKeyState: DWORD,
         _pt: *const POINTL,
-        _pdwEffect: *mut DWORD,
+        pdwEffect: *mut DWORD,
     ) -> HRESULT {
+        let drop_handler = Self::from_interface(this);
+        *pdwEffect = drop_handler.cursor_effect;
+
         S_OK
     }
 
     pub unsafe extern "system" fn DragLeave(this: *mut IDropTarget) -> HRESULT {
         use events::WindowEvent::HoveredFileCancelled;
         let drop_handler = Self::from_interface(this);
-        send_event(Event::WindowEvent {
-            window_id: SuperWindowId(WindowId(drop_handler.window)),
-            event: HoveredFileCancelled,
-        });
+        if drop_handler.hovered_is_valid {
+            send_event(Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(drop_handler.window)),
+                event: HoveredFileCancelled,
+            });
+        }
 
         S_OK
     }
@@ -126,7 +142,9 @@ impl FileDropHandler {
                 event: DroppedFile(filename),
             });
         });
-        shellapi::DragFinish(hdrop);
+        if let Some(hdrop) = hdrop {
+            shellapi::DragFinish(hdrop);
+        }
 
         S_OK
     }
@@ -135,12 +153,12 @@ impl FileDropHandler {
         &mut *(this as *mut _)
     }
 
-    unsafe fn iterate_filenames<F>(data_obj: *const IDataObject, callback: F) -> shellapi::HDROP
+    unsafe fn iterate_filenames<F>(data_obj: *const IDataObject, callback: F) -> Option<shellapi::HDROP>
     where
         F: Fn(PathBuf),
     {
         use winapi::ctypes::wchar_t;
-        use winapi::shared::winerror::SUCCEEDED;
+        use winapi::shared::winerror::{SUCCEEDED, DV_E_FORMATETC};
         use winapi::shared::wtypes::{CLIPFORMAT, DVASPECT_CONTENT};
         use winapi::um::objidl::{FORMATETC, TYMED_HGLOBAL};
         use winapi::um::shellapi::DragQueryFileW;
@@ -155,7 +173,8 @@ impl FileDropHandler {
         };
 
         let mut medium = mem::uninitialized();
-        if SUCCEEDED((*data_obj).GetData(&mut drop_format, &mut medium)) {
+        let get_data_result = (*data_obj).GetData(&mut drop_format, &mut medium);
+        if SUCCEEDED(get_data_result) {
             let hglobal = (*medium.u).hGlobal();
             let hdrop = (*hglobal) as shellapi::HDROP;
 
@@ -173,12 +192,16 @@ impl FileDropHandler {
                 }
             }
 
-            return hdrop;
+            return Some(hdrop);
+        } else if get_data_result == DV_E_FORMATETC {
+            // If the dropped item is not a file this error will occur.
+            // In this case it is OK to return without taking further action.
+            debug!("Error occured while processing dropped/hovered item: item is not a file.");
+            return None;
+        } else {
+            debug!("Unexpected error occured while processing dropped/hovered item.");
+            return None;
         }
-
-        // The call to `GetData` must succeed and the file handle must be returned before this
-        // point
-        unreachable!();
     }
 }
 

src/platform/windows/event.rs

@@ -1,33 +1,87 @@
-use std::char;
+use std::{char, ptr};
 use std::os::raw::c_int;
+use std::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
 
 use events::VirtualKeyCode;
 use events::ModifiersState;
 
-use winapi::shared::minwindef::{WPARAM, LPARAM, UINT};
+use winapi::shared::minwindef::{WPARAM, LPARAM, UINT, HKL, HKL__};
 use winapi::um::winuser;
 
 use ScanCode;
 
+fn key_pressed(vkey: c_int) -> bool {
+    unsafe {
+        (winuser::GetKeyState(vkey) & (1 << 15)) == (1 << 15)
+    }
+}
+
 pub fn get_key_mods() -> ModifiersState {
     let mut mods = ModifiersState::default();
-    unsafe {
-        if winuser::GetKeyState(winuser::VK_SHIFT) & (1 << 15) == (1 << 15) {
-            mods.shift = true;
-        }
-        if winuser::GetKeyState(winuser::VK_CONTROL) & (1 << 15) == (1 << 15) {
-            mods.ctrl = true;
-        }
-        if winuser::GetKeyState(winuser::VK_MENU) & (1 << 15) == (1 << 15) {
-            mods.alt = true;
-        }
-        if (winuser::GetKeyState(winuser::VK_LWIN) | winuser::GetKeyState(winuser::VK_RWIN)) & (1 << 15) == (1 << 15) {
-            mods.logo = true;
-        }
-    }
+    let filter_out_altgr = layout_uses_altgr() && key_pressed(winuser::VK_RMENU);
+
+    mods.shift = key_pressed(winuser::VK_SHIFT);
+    mods.ctrl = key_pressed(winuser::VK_CONTROL) && !filter_out_altgr;
+    mods.alt = key_pressed(winuser::VK_MENU) && !filter_out_altgr;
+    mods.logo = key_pressed(winuser::VK_LWIN) || key_pressed(winuser::VK_RWIN);
     mods
 }
 
+unsafe fn get_char(keyboard_state: &[u8; 256], v_key: u32, hkl: HKL) -> Option<char> {
+    let mut unicode_bytes = [0u16; 5];
+    let len = winuser::ToUnicodeEx(v_key, 0, keyboard_state.as_ptr(), unicode_bytes.as_mut_ptr(), unicode_bytes.len() as _, 0, hkl);
+    if len >= 1 {
+        char::decode_utf16(unicode_bytes.into_iter().cloned()).next().and_then(|c| c.ok())
+    } else {
+        None
+    }
+}
+
+/// Figures out if the keyboard layout has an AltGr key instead of an Alt key.
+///
+/// Unfortunately, the Windows API doesn't give a way for us to conveniently figure that out. So,
+/// we use a technique blatantly stolen from [the Firefox source code][source]: iterate over every
+/// possible virtual key and compare the `char` output when AltGr is pressed vs when it isn't. If
+/// pressing AltGr outputs characters that are different from the standard characters, the layout
+/// uses AltGr. Otherwise, it doesn't.
+///
+/// [source]: https://github.com/mozilla/gecko-dev/blob/265e6721798a455604328ed5262f430cfcc37c2f/widget/windows/KeyboardLayout.cpp#L4356-L4416
+fn layout_uses_altgr() -> bool {
+    unsafe {
+        static ACTIVE_LAYOUT: AtomicPtr<HKL__> = AtomicPtr::new(ptr::null_mut());
+        static USES_ALTGR: AtomicBool = AtomicBool::new(false);
+
+        let hkl = winuser::GetKeyboardLayout(0);
+        let old_hkl = ACTIVE_LAYOUT.swap(hkl, Ordering::SeqCst);
+
+        if hkl == old_hkl {
+            return USES_ALTGR.load(Ordering::SeqCst);
+        }
+
+        let mut keyboard_state_altgr = [0u8; 256];
+        // AltGr is an alias for Ctrl+Alt for... some reason. Whatever it is, those are the keypresses
+        // we have to emulate to do an AltGr test.
+        keyboard_state_altgr[winuser::VK_MENU as usize] = 0x80;
+        keyboard_state_altgr[winuser::VK_CONTROL as usize] = 0x80;
+
+        let keyboard_state_empty = [0u8; 256];
+
+        for v_key in 0..=255 {
+            let key_noaltgr = get_char(&keyboard_state_empty, v_key, hkl);
+            let key_altgr = get_char(&keyboard_state_altgr, v_key, hkl);
+            if let (Some(noaltgr), Some(altgr)) = (key_noaltgr, key_altgr) {
+                if noaltgr != altgr {
+                    USES_ALTGR.store(true, Ordering::SeqCst);
+                    return true;
+                }
+            }
+        }
+
+        USES_ALTGR.store(false, Ordering::SeqCst);
+        false
+    }
+}
+
 pub fn vkey_to_winit_vkey(vkey: c_int) -> Option<VirtualKeyCode> {
     // VK_* codes are documented here https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
     match vkey {

src/platform/windows/events_loop.rs

@@ -12,12 +12,14 @@
 //! The closure passed to the `execute_in_thread` method takes an `Inserter` that you can use to
 //! add a `WindowState` entry to a list of window to be used by the callback.
 
-use std::{mem, ptr, thread};
+use std::{mem, panic, ptr, thread};
+use std::any::Any;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::os::windows::io::AsRawHandle;
-use std::sync::{Arc, Barrier, mpsc, Mutex};
+use std::sync::{Arc, mpsc, Mutex};
 
+use backtrace::Backtrace;
 use winapi::ctypes::c_int;
 use winapi::shared::minwindef::{
     BOOL,
@@ -33,7 +35,7 @@ use winapi::shared::minwindef::{
 use winapi::shared::windef::{HWND, POINT, RECT};
 use winapi::shared::windowsx;
 use winapi::shared::winerror::S_OK;
-use winapi::um::{winuser, processthreadsapi, ole2};
+use winapi::um::{libloaderapi, processthreadsapi, ole2, winuser};
 use winapi::um::oleidl::LPDROPTARGET;
 use winapi::um::winnt::{LONG, LPCSTR, SHORT};
 
@@ -49,7 +51,7 @@ use {
     WindowId as SuperWindowId,
 };
 use events::{DeviceEvent, Touch, TouchPhase};
-use platform::platform::{event, Cursor, WindowId, DEVICE_ID, wrap_device_id, util};
+use platform::platform::{event, WindowId, DEVICE_ID, wrap_device_id, util};
 use platform::platform::dpi::{
     become_dpi_aware,
     dpi_to_scale_factor,
@@ -58,64 +60,9 @@ use platform::platform::dpi::{
 };
 use platform::platform::drop_handler::FileDropHandler;
 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;
-
-/// Contains saved window info for switching between fullscreen
-#[derive(Clone)]
-pub struct SavedWindowInfo {
-    /// Window style
-    pub style: LONG,
-    /// Window ex-style
-    pub ex_style: LONG,
-    /// Window position and size
-    pub rect: RECT,
-    // Since a window can be fullscreened to a different monitor, a DPI change can be triggered. This could result in
-    // the window being automitcally resized to smaller/larger than it was supposed to be restored to, so we thus must
-    // check if the post-fullscreen DPI matches the pre-fullscreen DPI.
-    pub is_fullscreen: bool,
-    pub dpi_factor: Option<f64>,
-}
-
-/// Contains information about states and the window that the callback is going to use.
-#[derive(Clone)]
-pub struct WindowState {
-    /// Cursor to set at the next `WM_SETCURSOR` event received.
-    pub cursor: Cursor,
-    pub cursor_grabbed: bool,
-    pub cursor_hidden: bool,
-    /// Used by `WM_GETMINMAXINFO`.
-    pub max_size: Option<PhysicalSize>,
-    pub min_size: Option<PhysicalSize>,
-    /// Will contain `true` if the mouse is hovering the window.
-    pub mouse_in_window: bool,
-    /// Saved window info for fullscreen restored
-    pub saved_window_info: Option<SavedWindowInfo>,
-    // 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 {
-    pub fn update_min_max(&mut self, old_dpi_factor: f64, new_dpi_factor: f64) {
-        let scale_factor = new_dpi_factor / old_dpi_factor;
-        let dpi_adjuster = |mut physical_size: PhysicalSize| -> PhysicalSize {
-            physical_size.width *= scale_factor;
-            physical_size.height *= scale_factor;
-            physical_size
-        };
-        self.max_size = self.max_size.map(&dpi_adjuster);
-        self.min_size = self.min_size.map(&dpi_adjuster);
-    }
-}
+use platform::platform::window_state::{CursorFlags, WindowFlags, WindowState};
 
 /// Dummy object that allows inserting a window's state.
 // We store a pointer in order to !impl Send and Sync.
@@ -134,10 +81,18 @@ impl Inserter {
 }
 
 pub struct EventsLoop {
+    thread_msg_target: HWND,
     // Id of the background thread from the Win32 API.
     thread_id: DWORD,
     // Receiver for the events. The sender is in the background thread.
-    receiver: mpsc::Receiver<Event>,
+    receiver: mpsc::Receiver<EventsLoopEvent>,
+    // Sender instance that's paired with the receiver. Used to construct an `EventsLoopProxy`.
+    sender: mpsc::Sender<EventsLoopEvent>,
+}
+
+enum EventsLoopEvent {
+    WinitEvent(Event),
+    Panic(PanicError),
 }
 
 impl EventsLoop {
@@ -146,23 +101,33 @@ impl EventsLoop {
     }
 
     pub fn with_dpi_awareness(dpi_aware: bool) -> EventsLoop {
+        struct InitData {
+            thread_msg_target: HWND,
+        }
+        unsafe impl Send for InitData {}
+
         become_dpi_aware(dpi_aware);
 
         // The main events transfer channel.
         let (tx, rx) = mpsc::channel();
 
-        // Local barrier in order to block the `new()` function until the background thread has
-        // an events queue.
-        let barrier = Arc::new(Barrier::new(2));
-        let barrier_clone = barrier.clone();
+        // Channel to send initialization data created on the event loop thread back to the main
+        // thread.
+        let (init_tx, init_rx) = mpsc::sync_channel(0);
 
+        let thread_sender = tx.clone();
+        let panic_sender = tx.clone();
         let thread = thread::spawn(move || {
+            let tx = thread_sender;
+            let thread_msg_target = thread_event_target_window();
+
             CONTEXT_STASH.with(|context_stash| {
                 *context_stash.borrow_mut() = Some(ThreadLocalData {
                     sender: tx,
                     windows: HashMap::with_capacity(4),
                     file_drop_handlers: HashMap::with_capacity(4),
                     mouse_buttons_down: 0,
+                    panic_error: None,
                 });
             });
 
@@ -173,38 +138,37 @@ impl EventsLoop {
                 winuser::IsGUIThread(1);
                 // Then only we unblock the `new()` function. We are sure that we don't call
                 // `PostThreadMessageA()` before `new()` returns.
-                barrier_clone.wait();
-                drop(barrier_clone);
+                init_tx.send(InitData{ thread_msg_target }).ok();
+                drop(init_tx);
 
                 let mut msg = mem::uninitialized();
 
                 loop {
                     if winuser::GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
+                        // If a panic occurred in the child callback, forward the panic information
+                        // to the parent thread.
+                        let panic_payload_opt = CONTEXT_STASH.with(|stash|
+                            stash.borrow_mut().as_mut()
+                                 .and_then(|s| s.panic_error.take())
+                        );
+                        if let Some(panic_payload) = panic_payload_opt {
+                            panic_sender.send(EventsLoopEvent::Panic(panic_payload)).unwrap();
+                        };
+
                         // Only happens if the message is `WM_QUIT`.
                         debug_assert_eq!(msg.message, winuser::WM_QUIT);
                         break;
                     }
 
-                    match msg.message {
-                        x if x == *EXEC_MSG_ID => {
-                            let mut function: Box<Box<FnMut(Inserter)>> = Box::from_raw(msg.wParam as usize as *mut _);
-                            function(Inserter(ptr::null_mut()));
-                        },
-                        x if x == *WAKEUP_MSG_ID => {
-                            send_event(Event::Awakened);
-                        },
-                        _ => {
-                            // Calls `callback` below.
-                            winuser::TranslateMessage(&msg);
-                            winuser::DispatchMessageW(&msg);
-                        }
-                    }
+                    // Calls `callback` below.
+                    winuser::TranslateMessage(&msg);
+                    winuser::DispatchMessageW(&msg);
                 }
             }
         });
 
         // Blocks this function until the background thread has an events loop. See other comments.
-        barrier.wait();
+        let InitData { thread_msg_target } = init_rx.recv().unwrap();
 
         let thread_id = unsafe {
             let handle = mem::transmute(thread.as_raw_handle());
@@ -212,8 +176,10 @@ impl EventsLoop {
         };
 
         EventsLoop {
+            thread_msg_target,
             thread_id,
             receiver: rx,
+            sender: tx,
         }
     }
 
@@ -222,8 +188,12 @@ impl EventsLoop {
     {
         loop {
             let event = match self.receiver.try_recv() {
-                Ok(e) => e,
-                Err(_) => return
+                Ok(EventsLoopEvent::WinitEvent(e)) => e,
+                Ok(EventsLoopEvent::Panic(panic)) => {
+                    eprintln!("resuming child thread unwind at: {:?}", Backtrace::new());
+                    panic::resume_unwind(panic)
+                },
+                Err(_) => break,
             };
 
             callback(event);
@@ -235,8 +205,12 @@ impl EventsLoop {
     {
         loop {
             let event = match self.receiver.recv() {
-                Ok(e) => e,
-                Err(_) => return
+                Ok(EventsLoopEvent::WinitEvent(e)) => e,
+                Ok(EventsLoopEvent::Panic(panic)) => {
+                    eprintln!("resuming child thread unwind at: {:?}", Backtrace::new());
+                    panic::resume_unwind(panic)
+                },
+                Err(_) => break,
             };
 
             let flow = callback(event);
@@ -250,6 +224,8 @@ impl EventsLoop {
     pub fn create_proxy(&self) -> EventsLoopProxy {
         EventsLoopProxy {
             thread_id: self.thread_id,
+            thread_msg_target: self.thread_msg_target,
+            sender: self.sender.clone(),
         }
     }
 
@@ -279,24 +255,16 @@ impl Drop for EventsLoop {
 #[derive(Clone)]
 pub struct EventsLoopProxy {
     thread_id: DWORD,
+    thread_msg_target: HWND,
+    sender: mpsc::Sender<EventsLoopEvent>,
 }
 
+unsafe impl Send for EventsLoopProxy {}
+unsafe impl Sync for EventsLoopProxy {}
+
 impl EventsLoopProxy {
     pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
-        unsafe {
-            if winuser::PostThreadMessageA(self.thread_id, *WAKEUP_MSG_ID, 0, 0) != 0 {
-                Ok(())
-            } else {
-                // https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms644946(v=vs.85).aspx
-                // > If the function fails, the return value is zero. To get extended error
-                // > information, call GetLastError. GetLastError returns ERROR_INVALID_THREAD_ID
-                // > if idThread is not a valid thread identifier, or if the thread specified by
-                // > idThread does not have a message queue. GetLastError returns
-                // > ERROR_NOT_ENOUGH_QUOTA when the message limit is hit.
-                // TODO: handle ERROR_NOT_ENOUGH_QUOTA
-                Err(EventsLoopClosed)
-            }
-        }
+        self.sender.send(EventsLoopEvent::WinitEvent(Event::Awakened)).map_err(|_| EventsLoopClosed)
     }
 
     /// Executes a function in the background thread.
@@ -312,36 +280,33 @@ impl EventsLoopProxy {
     /// `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)
+    pub fn execute_in_thread<F>(&self, mut function: F)
     where
         F: FnMut(Inserter) + Send + 'static,
     {
-        // We are using double-boxing here because it make casting back much easier
-        let double_box = Box::new(Box::new(function) as Box<FnMut(_)>);
-        let raw = Box::into_raw(double_box);
+        if unsafe{ processthreadsapi::GetCurrentThreadId() } == self.thread_id {
+            function(Inserter(ptr::null_mut()));
+        } else {
+            // We are using double-boxing here because it make casting back much easier
+            let double_box: ThreadExecFn = Box::new(Box::new(function) as Box<FnMut(_)>);
+            let raw = Box::into_raw(double_box);
 
-        let res = unsafe {
-            winuser::PostThreadMessageA(
-                self.thread_id,
-                *EXEC_MSG_ID,
-                raw as *mut () as usize as WPARAM,
-                0,
-            )
-        };
-        // PostThreadMessage can only fail if the thread ID is invalid (which shouldn't happen as
-        // the events loop is still alive) or if the queue is full.
-        assert!(res != 0, "PostThreadMessage failed; is the messages queue full?");
+            let res = unsafe {
+                winuser::PostMessageW(
+                    self.thread_msg_target,
+                    *EXEC_MSG_ID,
+                    raw as *mut () as usize as WPARAM,
+                    0,
+                )
+            };
+            assert!(res != 0, "PostMessage failed; is the messages queue full?");
+        }
     }
 }
 
+type ThreadExecFn = Box<Box<FnMut(Inserter)>>;
+
 lazy_static! {
-    // Message sent by the `EventsLoopProxy` when we want to wake up the thread.
-    // WPARAM and LPARAM are unused.
-    static ref WAKEUP_MSG_ID: u32 = {
-        unsafe {
-            winuser::RegisterWindowMessageA("Winit::WakeupMsg\0".as_ptr() as LPCSTR)
-        }
-    };
     // Message sent when we want to execute a closure in the thread.
     // WPARAM contains a Box<Box<FnMut()>> that must be retrieved with `Box::from_raw`,
     // and LPARAM is unused.
@@ -364,51 +329,141 @@ lazy_static! {
             winuser::RegisterWindowMessageA("Winit::InitialDpiMsg\0".as_ptr() as LPCSTR)
         }
     };
+    // WPARAM is a bool specifying the `WindowFlags::MARKER_RETAIN_STATE_ON_SIZE` flag. See the
+    // documentation in the `window_state` module for more information.
+    pub static ref SET_RETAIN_STATE_ON_SIZE_MSG_ID: u32 = unsafe {
+        winuser::RegisterWindowMessageA("Winit::SetRetainMaximized\0".as_ptr() as LPCSTR)
+    };
+    static ref THREAD_EVENT_TARGET_WINDOW_CLASS: Vec<u16> = unsafe {
+        use std::ffi::OsStr;
+        use std::os::windows::ffi::OsStrExt;
+
+        let class_name: Vec<_> = OsStr::new("Winit Thread Event Target")
+            .encode_wide()
+            .chain(Some(0).into_iter())
+            .collect();
+
+        let class = winuser::WNDCLASSEXW {
+            cbSize: mem::size_of::<winuser::WNDCLASSEXW>() as UINT,
+            style: 0,
+            lpfnWndProc: Some(thread_event_target_callback),
+            cbClsExtra: 0,
+            cbWndExtra: 0,
+            hInstance: libloaderapi::GetModuleHandleW(ptr::null()),
+            hIcon: ptr::null_mut(),
+            hCursor: ptr::null_mut(), // must be null in order for cursor state to work properly
+            hbrBackground: ptr::null_mut(),
+            lpszMenuName: ptr::null(),
+            lpszClassName: class_name.as_ptr(),
+            hIconSm: ptr::null_mut(),
+        };
+
+        winuser::RegisterClassExW(&class);
+
+        class_name
+    };
+}
+
+fn thread_event_target_window() -> HWND {
+    unsafe {
+        let window = winuser::CreateWindowExW(
+            winuser::WS_EX_NOACTIVATE | winuser::WS_EX_TRANSPARENT | winuser::WS_EX_LAYERED,
+            THREAD_EVENT_TARGET_WINDOW_CLASS.as_ptr(),
+            ptr::null_mut(),
+            0,
+            0, 0,
+            0, 0,
+            ptr::null_mut(),
+            ptr::null_mut(),
+            libloaderapi::GetModuleHandleW(ptr::null()),
+            ptr::null_mut(),
+        );
+        winuser::SetWindowLongPtrW(
+            window,
+            winuser::GWL_STYLE,
+            (winuser::WS_VISIBLE | winuser::WS_POPUP) as _
+        );
+
+        window
+    }
 }
 
 // There's no parameters passed to the callback function, so it needs to get its context stashed
 // in a thread-local variable.
 thread_local!(static CONTEXT_STASH: RefCell<Option<ThreadLocalData>> = RefCell::new(None));
 struct ThreadLocalData {
-    sender: mpsc::Sender<Event>,
+    sender: mpsc::Sender<EventsLoopEvent>,
     windows: HashMap<HWND, Arc<Mutex<WindowState>>>,
     file_drop_handlers: HashMap<HWND, FileDropHandler>, // Each window has its own drop handler.
     mouse_buttons_down: u32,
+    panic_error: Option<PanicError>,
 }
+type PanicError = Box<Any + Send + 'static>;
 
 // Utility function that dispatches an event on the current thread.
 pub fn send_event(event: Event) {
     CONTEXT_STASH.with(|context_stash| {
         let context_stash = context_stash.borrow();
 
-        let _ = context_stash.as_ref().unwrap().sender.send(event);   // Ignoring if closed
+        let _ = context_stash.as_ref().unwrap().sender.send(EventsLoopEvent::WinitEvent(event));   // Ignoring if closed
     });
 }
 
 /// Capture mouse input, allowing `window` to receive mouse events when the cursor is outside of
 /// the window.
 unsafe fn capture_mouse(window: HWND) {
-    CONTEXT_STASH.with(|context_stash| {
+    let set_capture = CONTEXT_STASH.with(|context_stash| {
         let mut context_stash = context_stash.borrow_mut();
         if let Some(context_stash) = context_stash.as_mut() {
             context_stash.mouse_buttons_down += 1;
-            winuser::SetCapture(window);
+            true
+        } else {
+            false
         }
     });
+    if set_capture {
+        winuser::SetCapture(window);
+    }
 }
 
 /// Release mouse input, stopping windows on this thread from receiving mouse input when the cursor
 /// is outside the window.
 unsafe fn release_mouse() {
-    CONTEXT_STASH.with(|context_stash| {
+    let release_capture = CONTEXT_STASH.with(|context_stash| {
         let mut context_stash = context_stash.borrow_mut();
         if let Some(context_stash) = context_stash.as_mut() {
             context_stash.mouse_buttons_down = context_stash.mouse_buttons_down.saturating_sub(1);
             if context_stash.mouse_buttons_down == 0 {
-                winuser::ReleaseCapture();
+                return true;
             }
         }
+        false
     });
+    if release_capture {
+        winuser::ReleaseCapture();
+    }
+}
+
+pub unsafe fn run_catch_panic<F, R>(error: R, f: F) -> R
+    where F: panic::UnwindSafe + FnOnce() -> R
+{
+    // If a panic has been triggered, cancel all future operations in the function.
+    if CONTEXT_STASH.with(|stash| stash.borrow().as_ref().map(|s| s.panic_error.is_some()).unwrap_or(false)) {
+        return error;
+    }
+
+    let callback_result = panic::catch_unwind(f);
+    match callback_result {
+        Ok(lresult) => lresult,
+        Err(err) => CONTEXT_STASH.with(|context_stash| {
+            let mut context_stash = context_stash.borrow_mut();
+            if let Some(context_stash) = context_stash.as_mut() {
+                context_stash.panic_error = Some(err);
+                winuser::PostQuitMessage(-1);
+            }
+            error
+        })
+    }
 }
 
 /// Any window whose callback is configured to this function will have its events propagated
@@ -423,6 +478,17 @@ pub unsafe extern "system" fn callback(
     msg: UINT,
     wparam: WPARAM,
     lparam: LPARAM,
+) -> LRESULT {
+    // Unwinding into foreign code is undefined behavior. So we catch any panics that occur in our
+    // code, and if a panic happens we cancel any future operations.
+    run_catch_panic(-1, || callback_inner(window, msg, wparam, lparam))
+}
+
+unsafe fn callback_inner(
+    window: HWND,
+    msg: UINT,
+    wparam: WPARAM,
+    lparam: LPARAM,
 ) -> LRESULT {
     match msg {
         winuser::WM_CREATE => {
@@ -514,20 +580,30 @@ pub unsafe extern "system" fn callback(
             let w = LOWORD(lparam as DWORD) as u32;
             let h = HIWORD(lparam as DWORD) as u32;
 
+            let dpi_factor = get_hwnd_scale_factor(window);
+            let logical_size = LogicalSize::from_physical((w, h), dpi_factor);
+            let event = Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(window)),
+                event: Resized(logical_size),
+            };
+
             // Wait for the parent thread to process the resize event before returning from the
             // callback.
             CONTEXT_STASH.with(|context_stash| {
                 let mut context_stash = context_stash.borrow_mut();
                 let cstash = context_stash.as_mut().unwrap();
 
-                let dpi_factor = get_hwnd_scale_factor(window);
-                let logical_size = LogicalSize::from_physical((w, h), dpi_factor);
-                let event = Event::WindowEvent {
-                    window_id: SuperWindowId(WindowId(window)),
-                    event: Resized(logical_size),
-                };
+                if let Some(w) = cstash.windows.get_mut(&window) {
+                    let mut w = w.lock().unwrap();
 
-                cstash.sender.send(event).ok();
+                    // See WindowFlags::MARKER_RETAIN_STATE_ON_SIZE docs for info on why this `if` check exists.
+                    if !w.window_flags().contains(WindowFlags::MARKER_RETAIN_STATE_ON_SIZE) {
+                        let maximized = wparam == winuser::SIZE_MAXIMIZED;
+                        w.set_window_flags_in_place(|f| f.set(WindowFlags::MAXIMIZED, maximized));
+                    }
+                }
+
+                cstash.sender.send(EventsLoopEvent::WinitEvent(event)).ok();
             });
             0
         },
@@ -553,22 +629,26 @@ pub unsafe extern "system" fn callback(
 
         winuser::WM_MOUSEMOVE => {
             use events::WindowEvent::{CursorEntered, CursorMoved};
-            let mouse_outside_window = CONTEXT_STASH.with(|context_stash| {
+            let x = windowsx::GET_X_LPARAM(lparam);
+            let y = windowsx::GET_Y_LPARAM(lparam);
+
+            let mouse_was_outside_window = CONTEXT_STASH.with(|context_stash| {
                 let mut context_stash = context_stash.borrow_mut();
                 if let Some(context_stash) = context_stash.as_mut() {
                     if let Some(w) = context_stash.windows.get_mut(&window) {
                         let mut w = w.lock().unwrap();
-                        if !w.mouse_in_window {
-                            w.mouse_in_window = true;
-                            return true;
-                        }
+
+                        let was_outside_window = !w.mouse.cursor_flags().contains(CursorFlags::IN_WINDOW);
+                        w.mouse.set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, true)).ok();
+                        return was_outside_window;
                     }
                 }
 
                 false
             });
 
-            if mouse_outside_window {
+
+            if mouse_was_outside_window {
                 send_event(Event::WindowEvent {
                     window_id: SuperWindowId(WindowId(window)),
                     event: CursorEntered { device_id: DEVICE_ID },
@@ -583,10 +663,8 @@ pub unsafe extern "system" fn callback(
                 });
             }
 
-            let x = windowsx::GET_X_LPARAM(lparam) as f64;
-            let y = windowsx::GET_Y_LPARAM(lparam) as f64;
             let dpi_factor = get_hwnd_scale_factor(window);
-            let position = LogicalPosition::from_physical((x, y), dpi_factor);
+            let position = LogicalPosition::from_physical((x as f64, y as f64), dpi_factor);
 
             send_event(Event::WindowEvent {
                 window_id: SuperWindowId(WindowId(window)),
@@ -598,27 +676,21 @@ pub unsafe extern "system" fn callback(
 
         winuser::WM_MOUSELEAVE => {
             use events::WindowEvent::CursorLeft;
-            let mouse_in_window = CONTEXT_STASH.with(|context_stash| {
+
+            CONTEXT_STASH.with(|context_stash| {
                 let mut context_stash = context_stash.borrow_mut();
                 if let Some(context_stash) = context_stash.as_mut() {
                     if let Some(w) = context_stash.windows.get_mut(&window) {
                         let mut w = w.lock().unwrap();
-                        if w.mouse_in_window {
-                            w.mouse_in_window = false;
-                            return true;
-                        }
+                        w.mouse.set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, false)).ok();
                     }
                 }
-
-                false
             });
 
-            if mouse_in_window {
-                send_event(Event::WindowEvent {
-                    window_id: SuperWindowId(WindowId(window)),
-                    event: CursorLeft { device_id: DEVICE_ID }
-                });
-            }
+            send_event(Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(window)),
+                event: CursorLeft { device_id: DEVICE_ID }
+            });
 
             0
         },
@@ -639,6 +711,22 @@ pub unsafe extern "system" fn callback(
             0
         },
 
+        winuser::WM_MOUSEHWHEEL => {
+            use events::MouseScrollDelta::LineDelta;
+            use events::TouchPhase;
+
+            let value = (wparam >> 16) as i16;
+            let value = value as i32;
+            let value = value as f32 / winuser::WHEEL_DELTA as f32;
+
+            send_event(Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(window)),
+                event: WindowEvent::MouseWheel { device_id: DEVICE_ID, delta: LineDelta(value, 0.0), phase: TouchPhase::Moved, modifiers: event::get_key_mods() },
+            });
+
+            0
+        },
+
         winuser::WM_KEYDOWN | winuser::WM_SYSKEYDOWN => {
             use events::ElementState::Pressed;
             use events::VirtualKeyCode;
@@ -964,22 +1052,12 @@ pub unsafe extern "system" fn callback(
         }
 
         winuser::WM_SETFOCUS => {
-            use events::WindowEvent::{Focused, CursorMoved};
+            use events::WindowEvent::Focused;
             send_event(Event::WindowEvent {
                 window_id: SuperWindowId(WindowId(window)),
                 event: Focused(true)
             });
 
-            let x = windowsx::GET_X_LPARAM(lparam) as f64;
-            let y = windowsx::GET_Y_LPARAM(lparam) as f64;
-            let dpi_factor = get_hwnd_scale_factor(window);
-            let position = LogicalPosition::from_physical((x, y), dpi_factor);
-
-            send_event(Event::WindowEvent {
-                window_id: SuperWindowId(WindowId(window)),
-                event: CursorMoved { device_id: DEVICE_ID, position, modifiers: event::get_key_mods() },
-            });
-
             0
         },
 
@@ -993,31 +1071,31 @@ pub unsafe extern "system" fn callback(
         },
 
         winuser::WM_SETCURSOR => {
-            let call_def_window_proc = CONTEXT_STASH.with(|context_stash| {
+            let set_cursor_to = CONTEXT_STASH.with(|context_stash| {
                 context_stash
                     .borrow()
                     .as_ref()
                     .and_then(|cstash| cstash.windows.get(&window))
-                    .map(|window_state_mutex| {
+                    .and_then(|window_state_mutex| {
                         let window_state = window_state_mutex.lock().unwrap();
-                        if window_state.mouse_in_window {
-                            let cursor = winuser::LoadCursorW(
-                                ptr::null_mut(),
-                                window_state.cursor.0,
-                            );
-                            winuser::SetCursor(cursor);
-                            false
+                        if window_state.mouse.cursor_flags().contains(CursorFlags::IN_WINDOW) {
+                            Some(window_state.mouse.cursor)
                         } else {
-                            true
+                            None
                         }
                     })
-                    .unwrap_or(true)
             });
 
-            if call_def_window_proc {
-                winuser::DefWindowProcW(window, msg, wparam, lparam)
-            } else {
-                0
+            match set_cursor_to {
+                Some(cursor) => {
+                    let cursor = winuser::LoadCursorW(
+                        ptr::null_mut(),
+                        cursor.to_windows_cursor(),
+                    );
+                    winuser::SetCursor(cursor);
+                    0
+                },
+                None => winuser::DefWindowProcW(window, msg, wparam, lparam)
             }
         },
 
@@ -1040,10 +1118,12 @@ pub unsafe extern "system" fn callback(
                             let style = winuser::GetWindowLongA(window, winuser::GWL_STYLE) as DWORD;
                             let ex_style = winuser::GetWindowLongA(window, winuser::GWL_EXSTYLE) as DWORD;
                             if let Some(min_size) = window_state.min_size {
+                                let min_size = min_size.to_physical(window_state.dpi_factor);
                                 let (width, height) = adjust_size(min_size, style, ex_style);
                                 (*mmi).ptMinTrackSize = POINT { x: width as i32, y: height as i32 };
                             }
                             if let Some(max_size) = window_state.max_size {
+                                let max_size = max_size.to_physical(window_state.dpi_factor);
                                 let (width, height) = adjust_size(max_size, style, ex_style);
                                 (*mmi).ptMaxTrackSize = POINT { x: width as i32, y: height as i32 };
                             }
@@ -1067,38 +1147,21 @@ pub unsafe extern "system" fn callback(
             let new_dpi_x = u32::from(LOWORD(wparam as DWORD));
             let new_dpi_factor = dpi_to_scale_factor(new_dpi_x);
 
-            let suppress_resize = CONTEXT_STASH.with(|context_stash| {
-                context_stash
-                    .borrow()
-                    .as_ref()
-                    .and_then(|cstash| cstash.windows.get(&window))
-                    .map(|window_state_mutex| {
-                        let mut window_state = window_state_mutex.lock().unwrap();
-                        let suppress_resize = window_state.saved_window_info
-                            .as_mut()
-                            .map(|saved_window_info| {
-                                let dpi_changed = if !saved_window_info.is_fullscreen {
-                                    saved_window_info.dpi_factor.take() != Some(new_dpi_factor)
-                                } else {
-                                    false
-                                };
-                                !dpi_changed || saved_window_info.is_fullscreen
-                            })
-                            .unwrap_or(false);
-                        // Now we adjust the min/max dimensions for the new DPI.
-                        if !suppress_resize {
-                            let old_dpi_factor = window_state.dpi_factor;
-                            window_state.update_min_max(old_dpi_factor, new_dpi_factor);
-                        }
-                        window_state.dpi_factor = new_dpi_factor;
-                        suppress_resize
-                    })
-                    .unwrap_or(false)
+            let allow_resize = CONTEXT_STASH.with(|context_stash| {
+                if let Some(wstash) = context_stash.borrow().as_ref().and_then(|cstash| cstash.windows.get(&window)) {
+                    let mut window_state = wstash.lock().unwrap();
+                    let old_dpi_factor = window_state.dpi_factor;
+                    window_state.dpi_factor = new_dpi_factor;
+
+                    new_dpi_factor != old_dpi_factor && window_state.fullscreen.is_none()
+                } else {
+                    true
+                }
             });
 
             // This prevents us from re-applying DPI adjustment to the restored size after exiting
             // fullscreen (the restored size is already DPI adjusted).
-            if !suppress_resize {
+            if allow_resize {
                 // Resize window to the size suggested by Windows.
                 let rect = &*(lparam as *const RECT);
                 winuser::SetWindowPos(
@@ -1164,9 +1227,38 @@ pub unsafe extern "system" fn callback(
                     | winuser::SWP_NOACTIVATE,
                 );
                 0
+            } else if msg == *SET_RETAIN_STATE_ON_SIZE_MSG_ID {
+                CONTEXT_STASH.with(|context_stash| {
+                    if let Some(cstash) = context_stash.borrow().as_ref() {
+                        if let Some(wstash) = cstash.windows.get(&window) {
+                            let mut window_state = wstash.lock().unwrap();
+                            window_state.set_window_flags_in_place(|f| f.set(WindowFlags::MARKER_RETAIN_STATE_ON_SIZE, wparam != 0));
+                        }
+                    }
+                });
+                0
             } else {
                 winuser::DefWindowProcW(window, msg, wparam, lparam)
             }
         }
     }
 }
+
+pub unsafe extern "system" fn thread_event_target_callback(
+    window: HWND,
+    msg: UINT,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    // See `callback` comment.
+    run_catch_panic(-1, || {
+        match msg {
+            _ if msg == *EXEC_MSG_ID => {
+                let mut function: ThreadExecFn = Box::from_raw(wparam as usize as *mut _);
+                function(Inserter(ptr::null_mut()));
+                0
+            },
+            _ => winuser::DefWindowProcW(window, msg, wparam, lparam)
+        }
+    })
+}

src/platform/windows/mod.rs

@@ -26,6 +26,12 @@ unsafe impl Sync for Cursor {}
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(u32);
 
+impl DeviceId {
+    pub unsafe fn dummy() -> Self {
+        DeviceId(0)
+    }
+}
+
 impl DeviceId {
     pub fn get_persistent_identifier(&self) -> Option<String> {
         if self.0 != 0 {
@@ -48,6 +54,14 @@ pub struct WindowId(HWND);
 unsafe impl Send for WindowId {}
 unsafe impl Sync for WindowId {}
 
+impl WindowId {
+    pub unsafe fn dummy() -> Self {
+        use std::ptr::null_mut;
+
+        WindowId(null_mut())
+    }
+}
+
 mod dpi;
 mod drop_handler;
 mod event;
@@ -57,3 +71,4 @@ mod monitor;
 mod raw_input;
 mod util;
 mod window;
+mod window_state;

src/platform/windows/monitor.rs

@@ -99,7 +99,7 @@ impl Window {
     }
 }
 
-fn get_monitor_info(hmonitor: HMONITOR) -> Result<winuser::MONITORINFOEXW, util::WinError> {
+pub(crate) fn get_monitor_info(hmonitor: HMONITOR) -> Result<winuser::MONITORINFOEXW, util::WinError> {
     let mut monitor_info: winuser::MONITORINFOEXW = unsafe { mem::uninitialized() };
     monitor_info.cbSize = mem::size_of::<winuser::MONITORINFOEXW>() as DWORD;
     let status = unsafe {

src/platform/windows/util.rs

@@ -1,6 +1,8 @@
-use std::{self, mem, ptr, slice};
+use std::{self, mem, ptr, slice, io};
 use std::ops::BitAnd;
+use std::sync::atomic::{AtomicBool, Ordering};
 
+use MouseCursor;
 use winapi::ctypes::wchar_t;
 use winapi::shared::minwindef::{BOOL, DWORD};
 use winapi::shared::windef::{HWND, POINT, RECT};
@@ -47,6 +49,14 @@ pub unsafe fn status_map<T, F: FnMut(&mut T) -> BOOL>(mut fun: F) -> Option<T> {
     }
 }
 
+fn win_to_err<F: FnOnce() -> BOOL>(f: F) -> Result<(), io::Error> {
+    if f() != 0 {
+        Ok(())
+    } else {
+        Err(io::Error::last_os_error())
+    }
+}
+
 pub fn get_cursor_pos() -> Option<POINT> {
     unsafe { status_map(|cursor_pos| winuser::GetCursorPos(cursor_pos)) }
 }
@@ -55,13 +65,56 @@ 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;
-    let right_eq = a.right == b.right;
-    let top_eq = a.top == b.top;
-    let bottom_eq = a.bottom == b.bottom;
-    left_eq && right_eq && top_eq && bottom_eq
+pub fn get_client_rect(hwnd: HWND) -> Result<RECT, io::Error> {
+    unsafe {
+        let mut rect = mem::uninitialized();
+        let mut top_left = mem::zeroed();
+
+        win_to_err(|| winuser::ClientToScreen(hwnd, &mut top_left))?;
+        win_to_err(|| winuser::GetClientRect(hwnd, &mut rect))?;
+        rect.left += top_left.x;
+        rect.top += top_left.y;
+        rect.right += top_left.x;
+        rect.bottom += top_left.y;
+
+        Ok(rect)
+    }
+}
+
+pub fn adjust_window_rect(hwnd: HWND, rect: RECT) -> Option<RECT> {
+    unsafe {
+        let style = winuser::GetWindowLongW(hwnd, winuser::GWL_STYLE);
+        let style_ex = winuser::GetWindowLongW(hwnd, winuser::GWL_EXSTYLE);
+        adjust_window_rect_with_styles(hwnd, style as _, style_ex as _, rect)
+    }
+}
+
+pub fn adjust_window_rect_with_styles(hwnd: HWND, style: DWORD, style_ex: DWORD, rect: RECT) -> Option<RECT> {
+    unsafe { status_map(|r| {
+        *r = rect;
+
+        let b_menu = !winuser::GetMenu(hwnd).is_null() as BOOL;
+        winuser::AdjustWindowRectEx(r, style as _ , b_menu, style_ex as _)
+    }) }
+}
+
+pub fn set_cursor_hidden(hidden: bool) {
+    static HIDDEN: AtomicBool = AtomicBool::new(false);
+    let changed = HIDDEN.swap(hidden, Ordering::SeqCst) ^ hidden;
+    if changed {
+        unsafe{ winuser::ShowCursor(!hidden as BOOL) };
+    }
+}
+
+pub fn set_cursor_clip(rect: Option<RECT>) -> Result<(), io::Error> {
+    unsafe {
+        let rect_ptr = rect.as_ref().map(|r| r as *const RECT).unwrap_or(ptr::null());
+        win_to_err(|| winuser::ClipCursor(rect_ptr))
+    }
+}
+
+pub fn is_focused(window: HWND) -> bool {
+    window == unsafe{ winuser::GetActiveWindow() }
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -102,3 +155,29 @@ pub unsafe fn get_last_error() -> Option<String> {
     }
     None
 }
+
+impl MouseCursor {
+    pub(crate) fn to_windows_cursor(self) -> *const wchar_t {
+        match self {
+            MouseCursor::Arrow | MouseCursor::Default => winuser::IDC_ARROW,
+            MouseCursor::Hand => winuser::IDC_HAND,
+            MouseCursor::Crosshair => winuser::IDC_CROSS,
+            MouseCursor::Text | MouseCursor::VerticalText => winuser::IDC_IBEAM,
+            MouseCursor::NotAllowed | MouseCursor::NoDrop => winuser::IDC_NO,
+            MouseCursor::Grab | MouseCursor::Grabbing |
+            MouseCursor::Move | MouseCursor::AllScroll => winuser::IDC_SIZEALL,
+            MouseCursor::EResize | MouseCursor::WResize |
+            MouseCursor::EwResize | MouseCursor::ColResize => winuser::IDC_SIZEWE,
+            MouseCursor::NResize | MouseCursor::SResize |
+            MouseCursor::NsResize | MouseCursor::RowResize => winuser::IDC_SIZENS,
+            MouseCursor::NeResize | MouseCursor::SwResize |
+            MouseCursor::NeswResize => winuser::IDC_SIZENESW,
+            MouseCursor::NwResize | MouseCursor::SeResize |
+            MouseCursor::NwseResize => winuser::IDC_SIZENWSE,
+            MouseCursor::Wait => winuser::IDC_WAIT,
+            MouseCursor::Progress => winuser::IDC_APPSTARTING,
+            MouseCursor::Help => winuser::IDC_HELP,
+            _ => winuser::IDC_ARROW, // use arrow for the missing cases.
+        }
+    }
+}

src/platform/windows/window.rs

@@ -8,8 +8,8 @@ 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::{HWND, LPPOINT, POINT, RECT};
+use winapi::shared::minwindef::{DWORD, LPARAM, UINT, WORD, WPARAM};
+use winapi::shared::windef::{HWND, POINT, RECT};
 use winapi::um::{combaseapi, dwmapi, libloaderapi, winuser};
 use winapi::um::objbase::COINIT_MULTITHREADED;
 use winapi::um::shobjidl_core::{CLSID_TaskbarList, ITaskbarList2};
@@ -26,16 +26,16 @@ use {
     PhysicalSize,
     WindowAttributes,
 };
-use platform::platform::{Cursor, PlatformSpecificWindowBuilderAttributes, WindowId};
+use platform::platform::{PlatformSpecificWindowBuilderAttributes, WindowId};
 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;
+use platform::platform::window_state::{CursorFlags, SavedWindow, WindowFlags, WindowState};
 
-const WS_RESIZABLE: DWORD = winuser::WS_SIZEBOX | winuser::WS_MAXIMIZEBOX;
+use raw_window_handle::{windows::WindowsHandle, RawWindowHandle};
 
 /// The Win32 implementation of the main `Window` object.
 pub struct Window {
@@ -49,28 +49,6 @@ pub struct Window {
     events_loop_proxy: events_loop::EventsLoopProxy,
 }
 
-// https://blogs.msdn.microsoft.com/oldnewthing/20131017-00/?p=2903
-// The idea here is that we use the Adjust­Window­Rect­Ex function to calculate how much additional
-// non-client area gets added due to the styles we passed. To make the math simple,
-// we ask for a zero client rectangle, so that the resulting window is all non-client.
-// And then we pass in the empty rectangle represented by the dot in the middle,
-// and the Adjust­Window­Rect­Ex expands the rectangle in all dimensions.
-// We see that it added ten pixels to the left, right, and bottom,
-// and it added fifty pixels to the top.
-// From this we can perform the reverse calculation: Instead of expanding the rectangle, we shrink it.
-unsafe fn unjust_window_rect(prc: &mut RECT, style: DWORD, ex_style: DWORD) -> BOOL {
-    let mut rc: RECT = mem::uninitialized();
-    winuser::SetRectEmpty(&mut rc);
-    let status = winuser::AdjustWindowRectEx(&mut rc, style, 0, ex_style);
-    if status != 0 {
-        prc.left -= rc.left;
-        prc.top -= rc.top;
-        prc.right -= rc.right;
-        prc.bottom -= rc.bottom;
-    }
-    status
-}
-
 impl Window {
     pub fn new(
         events_loop: &EventsLoop,
@@ -204,16 +182,16 @@ impl Window {
 
     pub(crate) fn set_inner_size_physical(&self, x: u32, y: u32) {
         unsafe {
-            let mut rect = RECT {
-                top: 0,
-                left: 0,
-                bottom: y as LONG,
-                right: x as LONG,
-            };
-            let dw_style = winuser::GetWindowLongA(self.window.0, winuser::GWL_STYLE) as DWORD;
-            let b_menu = !winuser::GetMenu(self.window.0).is_null() as BOOL;
-            let dw_style_ex = winuser::GetWindowLongA(self.window.0, winuser::GWL_EXSTYLE) as DWORD;
-            winuser::AdjustWindowRectEx(&mut rect, dw_style, b_menu, dw_style_ex);
+            let rect = util::adjust_window_rect(
+                self.window.0,
+                RECT {
+                    top: 0,
+                    left: 0,
+                    bottom: y as LONG,
+                    right: x as LONG,
+                }
+            ).expect("adjust_window_rect failed");
+
             let outer_x = (rect.right - rect.left).abs() as c_int;
             let outer_y = (rect.top - rect.bottom).abs() as c_int;
             winuser::SetWindowPos(
@@ -273,25 +251,17 @@ impl Window {
 
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
-        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.
-            if window_state.fullscreen.is_none() {
-                let mut style = unsafe {
-                    winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE)
-                };
+        let window = self.window.clone();
+        let window_state = Arc::clone(&self.window_state);
 
-                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.events_loop_proxy.execute_in_thread(move |_| {
+            WindowState::set_window_flags(
+                window_state.lock().unwrap(),
+                window.0,
+                None,
+                |f| f.set(WindowFlags::RESIZABLE, resizable),
+            );
+        });
     }
 
     /// Returns the `hwnd` of this window.
@@ -300,125 +270,55 @@ impl Window {
         self.window.0
     }
 
+    #[inline]
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let handle = WindowsHandle {
+            hwnd: self.window.0 as *mut _,
+            ..WindowsHandle::empty()
+        };
+        RawWindowHandle::Windows(handle)
+    }
+
     #[inline]
     pub fn set_cursor(&self, cursor: MouseCursor) {
-        let cursor_id = Cursor(match cursor {
-            MouseCursor::Arrow | MouseCursor::Default => winuser::IDC_ARROW,
-            MouseCursor::Hand => winuser::IDC_HAND,
-            MouseCursor::Crosshair => winuser::IDC_CROSS,
-            MouseCursor::Text | MouseCursor::VerticalText => winuser::IDC_IBEAM,
-            MouseCursor::NotAllowed | MouseCursor::NoDrop => winuser::IDC_NO,
-            MouseCursor::Grab | MouseCursor::Grabbing |
-            MouseCursor::Move | MouseCursor::AllScroll => winuser::IDC_SIZEALL,
-            MouseCursor::EResize | MouseCursor::WResize |
-            MouseCursor::EwResize | MouseCursor::ColResize => winuser::IDC_SIZEWE,
-            MouseCursor::NResize | MouseCursor::SResize |
-            MouseCursor::NsResize | MouseCursor::RowResize => winuser::IDC_SIZENS,
-            MouseCursor::NeResize | MouseCursor::SwResize |
-            MouseCursor::NeswResize => winuser::IDC_SIZENESW,
-            MouseCursor::NwResize | MouseCursor::SeResize |
-            MouseCursor::NwseResize => winuser::IDC_SIZENWSE,
-            MouseCursor::Wait => winuser::IDC_WAIT,
-            MouseCursor::Progress => winuser::IDC_APPSTARTING,
-            MouseCursor::Help => winuser::IDC_HELP,
-            _ => winuser::IDC_ARROW, // use arrow for the missing cases.
-        });
-        self.window_state.lock().unwrap().cursor = cursor_id;
+        self.window_state.lock().unwrap().mouse.cursor = cursor;
         self.events_loop_proxy.execute_in_thread(move |_| unsafe {
             let cursor = winuser::LoadCursorW(
                 ptr::null_mut(),
-                cursor_id.0,
+                cursor.to_windows_cursor(),
             );
             winuser::SetCursor(cursor);
         });
     }
 
-    unsafe fn cursor_is_grabbed(&self) -> Result<bool, String> {
-        let mut client_rect: RECT = mem::uninitialized();
-        let mut clip_rect: RECT = mem::uninitialized();
-        if winuser::GetClientRect(self.window.0, &mut client_rect) == 0 {
-            return Err("`GetClientRect` failed".to_owned());
-        }
-        // A `POINT` is two `LONG`s (x, y), and the `RECT` field after `left` is `top`.
-        if winuser::ClientToScreen(self.window.0, &mut client_rect.left as *mut _ as LPPOINT) == 0 {
-            return Err("`ClientToScreen` (left, top) failed".to_owned());
-        }
-        if winuser::ClientToScreen(self.window.0, &mut client_rect.right as *mut _ as LPPOINT) == 0 {
-            return Err("`ClientToScreen` (right, bottom) failed".to_owned());
-        }
-        if winuser::GetClipCursor(&mut clip_rect) == 0 {
-            return Err("`GetClipCursor` failed".to_owned());
-        }
-        Ok(util::rect_eq(&client_rect, &clip_rect))
-    }
-
-    pub(crate) unsafe fn grab_cursor_inner(window: &WindowWrapper, grab: bool) -> Result<(), String> {
-        if grab {
-            let mut rect = mem::uninitialized();
-            if winuser::GetClientRect(window.0, &mut rect) == 0 {
-                return Err("`GetClientRect` failed".to_owned());
-            }
-            // A `POINT` is two `LONG`s (x, y), and the `RECT` field after `left` is `top`.
-            if winuser::ClientToScreen(window.0, &mut rect.left as *mut _ as LPPOINT) == 0 {
-                return Err("`ClientToScreen` (left, top) failed".to_owned());
-            }
-            if winuser::ClientToScreen(window.0, &mut rect.right as *mut _ as LPPOINT) == 0 {
-                return Err("`ClientToScreen` (right, bottom) failed".to_owned());
-            }
-            if winuser::ClipCursor(&rect) == 0 {
-                return Err("`ClipCursor` failed".to_owned());
-            }
-        } else {
-            if winuser::ClipCursor(ptr::null()) == 0 {
-                return Err("`ClipCursor` failed".to_owned());
-            }
-        }
-        Ok(())
-    }
-
     #[inline]
     pub fn grab_cursor(&self, grab: bool) -> Result<(), String> {
-        let currently_grabbed = unsafe { self.cursor_is_grabbed() }?;
-        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) };
-            if result.is_ok() {
-                window_state.lock().unwrap().cursor_grabbed = grab;
-            }
+            let result = window_state.lock().unwrap().mouse
+                .set_cursor_flags(window.0, |f| f.set(CursorFlags::GRABBED, grab))
+                .map_err(|e| e.to_string());
             let _ = tx.send(result);
         });
-        drop(window_state_lock);
         rx.recv().unwrap()
     }
 
-    pub(crate) unsafe fn hide_cursor_inner(hide: bool) {
-        if hide {
-            winuser::ShowCursor(FALSE);
-        } else {
-            winuser::ShowCursor(TRUE);
-        }
-    }
-
     #[inline]
     pub fn hide_cursor(&self, hide: bool) {
-        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 = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
+        let (tx, rx) = channel();
+
         self.events_loop_proxy.execute_in_thread(move |_| {
-            unsafe { Self::hide_cursor_inner(hide) };
-            window_state.lock().unwrap().cursor_hidden = hide;
-            let _ = tx.send(());
+            let result = window_state.lock().unwrap().mouse
+                .set_cursor_flags(window.0, |f| f.set(CursorFlags::HIDDEN, hide))
+                .map_err(|e| e.to_string());
+            let _ = tx.send(result);
         });
-        drop(window_state_lock);
-        rx.recv().unwrap()
+        rx.recv().unwrap().ok();
     }
 
     #[inline]
@@ -453,276 +353,113 @@ impl Window {
 
     #[inline]
     pub fn set_maximized(&self, maximized: bool) {
-        let mut window_state = self.window_state.lock().unwrap();
-        if mem::replace(&mut window_state.maximized, maximized) != maximized {
-            // We only maximize if we're not in fullscreen.
-            if window_state.fullscreen.is_none() {
-                let window = self.window.clone();
-                unsafe {
-                    // `ShowWindow` resizes the window, so it must be called from the main thread.
-                    self.events_loop_proxy.execute_in_thread(move |_| {
-                        winuser::ShowWindow(
-                            window.0,
-                            if maximized {
-                                winuser::SW_MAXIMIZE
-                            } else {
-                                winuser::SW_RESTORE
-                            },
-                        );
-                    });
-                }
-            }
-        }
-    }
-
-    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(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),
-                rect,
-                is_fullscreen: true,
-                dpi_factor,
-            });
-        }
-
-        // We sync the system maximized state here, it will be used when restoring
-        let mut placement: winuser::WINDOWPLACEMENT = mem::zeroed();
-        placement.length = mem::size_of::<winuser::WINDOWPLACEMENT>() as u32;
-        winuser::GetWindowPlacement(self.window.0, &mut placement);
-        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, window_state_lock: &mut WindowState) {
-        let (rect, mut style, ex_style) = {
-            // '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() {
-                return;
-            }
-
-            let saved_window_info = window_state_lock.saved_window_info.as_mut().unwrap();
-
-            // Reset original window style and size.  The multiple window size/moves
-            // here are ugly, but if SetWindowPos() doesn't redraw, the taskbar won't be
-            // repainted.  Better-looking methods welcome.
-            saved_window_info.is_fullscreen = false;
-
-            let rect = saved_window_info.rect.clone();
-            let (style, ex_style) = (saved_window_info.style, saved_window_info.ex_style);
-            (rect, style, ex_style)
-        };
         let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
-        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.
         self.events_loop_proxy.execute_in_thread(move |_| {
-            let _ = Self::grab_cursor_inner(&window, false);
-
-            if resizable {
-                style |= WS_RESIZABLE as LONG;
-            } else {
-                style &= !WS_RESIZABLE as LONG;
-            }
-            winuser::SetWindowLongW(window.0, winuser::GWL_STYLE, style);
-            winuser::SetWindowLongW(window.0, winuser::GWL_EXSTYLE, ex_style);
-
-            winuser::SetWindowPos(
+            WindowState::set_window_flags(
+                window_state.lock().unwrap(),
                 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,
+                None,
+                |f| f.set(WindowFlags::MAXIMIZED, maximized),
             );
-
-            // We apply any requested changes to maximization state that occurred while we were in fullscreen.
-            winuser::ShowWindow(
-                window.0,
-                if maximized {
-                    winuser::SW_MAXIMIZE
-                } else {
-                    winuser::SW_RESTORE
-                },
-            );
-
-            mark_fullscreen(window.0, false);
-
-            let window_state_lock = window_state.lock().unwrap();
-            let _ = Self::grab_cursor_inner(&window, window_state_lock.cursor_grabbed);
         });
     }
 
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<RootMonitorId> {
+        let window_state = self.window_state.lock().unwrap();
+        window_state.fullscreen.clone()
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, monitor: Option<RootMonitorId>) {
-        let mut window_state_lock = self.window_state.lock().unwrap();
         unsafe {
+            let window = self.window.clone();
+            let window_state = Arc::clone(&self.window_state);
+
             match &monitor {
                 &Some(RootMonitorId { ref inner }) => {
                     let (x, y): (i32, i32) = inner.get_position().into();
                     let (width, height): (u32, u32) = inner.get_dimensions().into();
-                    let window = self.window.clone();
-                    let window_state = Arc::clone(&self.window_state);
 
-                    let (style, ex_style) = self.set_fullscreen_style(&mut window_state_lock);
+                    let mut monitor = monitor.clone();
                     self.events_loop_proxy.execute_in_thread(move |_| {
-                        let _ = Self::grab_cursor_inner(&window, false);
+                        let mut window_state_lock = window_state.lock().unwrap();
 
-                        winuser::SetWindowLongW(
-                            window.0,
-                            winuser::GWL_STYLE,
-                            ((style as DWORD) & !(winuser::WS_CAPTION | winuser::WS_THICKFRAME))
-                                as LONG,
-                        );
+                        let client_rect = util::get_client_rect(window.0).expect("get client rect failed!");
+                        window_state_lock.saved_window = Some(SavedWindow {
+                            client_rect,
+                            dpi_factor: window_state_lock.dpi_factor
+                        });
 
-                        winuser::SetWindowLongW(
+                        window_state_lock.fullscreen = monitor.take();
+                        WindowState::refresh_window_state(
+                            window_state_lock,
                             window.0,
-                            winuser::GWL_EXSTYLE,
-                            ((ex_style as DWORD)
-                                & !(winuser::WS_EX_DLGMODALFRAME | winuser::WS_EX_WINDOWEDGE
-                                    | winuser::WS_EX_CLIENTEDGE
-                                    | winuser::WS_EX_STATICEDGE))
-                                as LONG,
-                        );
-
-                        winuser::SetWindowPos(
-                            window.0,
-                            ptr::null_mut(),
-                            x as c_int,
-                            y as c_int,
-                            width as c_int,
-                            height as c_int,
-                            winuser::SWP_ASYNCWINDOWPOS | winuser::SWP_NOZORDER
-                                | winuser::SWP_NOACTIVATE
-                                | winuser::SWP_FRAMECHANGED,
+                            Some(RECT {
+                                left: x,
+                                top: y,
+                                right: x + width as c_int,
+                                bottom: y + height as c_int,
+                            })
                         );
 
                         mark_fullscreen(window.0, true);
-
-                        let window_state_lock = window_state.lock().unwrap();
-                        let _ = Self::grab_cursor_inner(&window, window_state_lock.cursor_grabbed);
                     });
                 }
                 &None => {
-                    self.restore_saved_window(&mut window_state_lock);
+                    self.events_loop_proxy.execute_in_thread(move |_| {
+                        let mut window_state_lock = window_state.lock().unwrap();
+                        window_state_lock.fullscreen = None;
+
+                        if let Some(SavedWindow{client_rect, dpi_factor}) = window_state_lock.saved_window {
+                            window_state_lock.dpi_factor = dpi_factor;
+                            window_state_lock.saved_window = None;
+
+                            WindowState::refresh_window_state(
+                                window_state_lock,
+                                window.0,
+                                Some(client_rect)
+                            );
+                        }
+
+                        mark_fullscreen(window.0, false);
+                    });
                 }
             }
         }
-
-        window_state_lock.fullscreen = monitor;
     }
 
     #[inline]
     pub fn set_decorations(&self, decorations: bool) {
-        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;
+        let window = self.window.clone();
+        let window_state = Arc::clone(&self.window_state);
 
-            // 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 {
-                    unjust_window_rect(&mut saved.rect, saved.style as _, saved.ex_style as _);
-                }
-
-                if decorations {
-                    saved.style = saved.style | style_flags;
-                    saved.ex_style = saved.ex_style | ex_style_flags;
-                } else {
-                    saved.style = saved.style & !style_flags;
-                    saved.ex_style = saved.ex_style & !ex_style_flags;
-                }
-
-                unsafe {
-                    winuser::AdjustWindowRectEx(
-                        &mut saved.rect,
-                        saved.style as _,
-                        0,
-                        saved.ex_style as _,
-                    );
-                }
-            } else {
-                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,
-                        );
-                    });
-                }
-            }
-        }
+        self.events_loop_proxy.execute_in_thread(move |_| {
+            let client_rect = util::get_client_rect(window.0).expect("get client rect failed!");
+            WindowState::set_window_flags(
+                window_state.lock().unwrap(),
+                window.0,
+                Some(client_rect),
+                |f| f.set(WindowFlags::DECORATIONS, decorations),
+            );
+        });
     }
 
     #[inline]
     pub fn set_always_on_top(&self, always_on_top: bool) {
-        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();
+        let window_state = Arc::clone(&self.window_state);
+
+        self.events_loop_proxy.execute_in_thread(move |_| {
+            WindowState::set_window_flags(
+                window_state.lock().unwrap(),
+                window.0,
+                None,
+                |f| f.set(WindowFlags::ALWAYS_ON_TOP, always_on_top),
+            );
+        });
     }
 
     #[inline]
@@ -873,84 +610,27 @@ unsafe fn init(
     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,
-        right: width as LONG,
-        top: 0,
-        bottom: height as LONG,
-    };
 
-    // computing the style and extended style of the window
-    let (mut ex_style, style) = if !attributes.decorations {
-        (winuser::WS_EX_APPWINDOW,
-            //winapi::WS_POPUP is incompatible with winapi::WS_CHILD
-            if pl_attribs.parent.is_some() {
-                winuser::WS_CLIPSIBLINGS | winuser::WS_CLIPCHILDREN
-            }
-            else {
-                winuser::WS_POPUP | winuser::WS_CLIPSIBLINGS | winuser::WS_CLIPCHILDREN
-            }
-        )
-    } else {
-        (winuser::WS_EX_APPWINDOW | winuser::WS_EX_WINDOWEDGE,
-            winuser::WS_OVERLAPPEDWINDOW | winuser::WS_CLIPSIBLINGS | winuser::WS_CLIPCHILDREN)
-    };
-
-    if attributes.always_on_top {
-        ex_style |= winuser::WS_EX_TOPMOST;
-    }
-    if pl_attribs.no_redirection_bitmap {
-        ex_style |= winuser::WS_EX_NOREDIRECTIONBITMAP;
-    }
-    if attributes.transparent && attributes.decorations {
-        ex_style |= winuser::WS_EX_LAYERED;
-    }
-
-    // adjusting the window coordinates using the style
-    winuser::AdjustWindowRectEx(&mut rect, style, 0, ex_style);
+    let mut window_flags = WindowFlags::empty();
+    window_flags.set(WindowFlags::DECORATIONS, attributes.decorations);
+    window_flags.set(WindowFlags::ALWAYS_ON_TOP, attributes.always_on_top);
+    window_flags.set(WindowFlags::NO_BACK_BUFFER, pl_attribs.no_redirection_bitmap);
+    window_flags.set(WindowFlags::TRANSPARENT, attributes.transparent);
+    // WindowFlags::VISIBLE and MAXIMIZED are set down below after the window has been configured.
+    window_flags.set(WindowFlags::RESIZABLE, attributes.resizable);
+    window_flags.set(WindowFlags::CHILD, pl_attribs.parent.is_some());
+    window_flags.set(WindowFlags::ON_TASKBAR, true);
 
     // creating the real window this time, by using the functions in `extra_functions`
     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, 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, guessed_dpi_factor))
-                .map(|physical_size| adjust_size(physical_size, style, ex_style))
-                .unwrap_or((c_int::max_value(), c_int::max_value()));
-            (
-                Some((rect.right - rect.left).min(max_dimensions.0).max(min_dimensions.0)),
-                Some((rect.bottom - rect.top).min(max_dimensions.1).max(min_dimensions.1))
-            )
-        } else {
-            (None, None)
-        };
-
-        let mut style = if !attributes.visible {
-            style
-        } else {
-            style | winuser::WS_VISIBLE
-        };
-
-        if !attributes.resizable {
-            style &= !WS_RESIZABLE;
-        }
-
-        if pl_attribs.parent.is_some() {
-            style |= winuser::WS_CHILD;
-        }
-
-        let handle = winuser::CreateWindowExW(ex_style | winuser::WS_EX_ACCEPTFILES,
+        let (style, ex_style) = window_flags.to_window_styles();
+        let handle = winuser::CreateWindowExW(
+            ex_style,
             class_name.as_ptr(),
             title.as_ptr() as LPCWSTR,
-            style | winuser::WS_CLIPSIBLINGS | winuser::WS_CLIPCHILDREN,
+            style,
+            winuser::CW_USEDEFAULT, winuser::CW_USEDEFAULT,
             winuser::CW_USEDEFAULT, winuser::CW_USEDEFAULT,
-            adjusted_width.unwrap_or(winuser::CW_USEDEFAULT),
-            adjusted_height.unwrap_or(winuser::CW_USEDEFAULT),
             pl_attribs.parent.unwrap_or(ptr::null_mut()),
             ptr::null_mut(),
             libloaderapi::GetModuleHandleW(ptr::null()),
@@ -993,32 +673,6 @@ unsafe fn init(
         );
     }
 
-    let window_state = {
-        let max_size = attributes.max_dimensions
-            .map(|logical_size| PhysicalSize::from_logical(logical_size, dpi_factor));
-        let min_size = attributes.min_dimensions
-            .map(|logical_size| PhysicalSize::from_logical(logical_size, dpi_factor));
-        let mut window_state = events_loop::WindowState {
-            cursor: Cursor(winuser::IDC_ARROW), // use arrow by default
-            cursor_grabbed: false,
-            cursor_hidden: false,
-            max_size,
-            min_size,
-            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))
-    };
-
     // making the window transparent
     if attributes.transparent && !pl_attribs.no_redirection_bitmap {
         let region = CreateRectRgn(0, 0, -1, -1); // makes the window transparent
@@ -1046,18 +700,41 @@ unsafe fn init(
         }
     }
 
+    window_flags.set(WindowFlags::VISIBLE, attributes.visible);
+    window_flags.set(WindowFlags::MAXIMIZED, attributes.maximized);
+
+    let window_state = {
+        let mut window_state = WindowState::new(
+            &attributes,
+            window_icon,
+            taskbar_icon,
+            dpi_factor,
+        );
+        let window_state = Arc::new(Mutex::new(window_state));
+        WindowState::set_window_flags(
+            window_state.lock().unwrap(),
+            real_window.0,
+            None,
+            |f| *f = window_flags,
+        );
+        window_state
+    };
+
     let win = Window {
         window: real_window,
         window_state,
         events_loop_proxy,
     };
 
-    win.set_maximized(attributes.maximized);
     if let Some(_) = attributes.fullscreen {
         win.set_fullscreen(attributes.fullscreen);
         force_window_active(win.window.0);
     }
 
+    if let Some(dimensions) = attributes.dimensions {
+        win.set_inner_size(dimensions);
+    }
+
     inserter.insert(win.window.0, win.window_state.clone());
 
     Ok(win)

src/platform/windows/window_state.rs

@@ -0,0 +1,329 @@
+use {MouseCursor, WindowAttributes};
+use std::{io, ptr};
+use std::sync::MutexGuard;
+use dpi::LogicalSize;
+use platform::platform::{util, events_loop};
+use platform::platform::icon::WinIcon;
+use winapi::shared::windef::{RECT, HWND};
+use winapi::shared::minwindef::DWORD;
+use winapi::um::winuser;
+
+/// Contains information about states and the window that the callback is going to use.
+#[derive(Clone)]
+pub struct WindowState {
+    pub mouse: MouseProperties,
+
+    /// Used by `WM_GETMINMAXINFO`.
+    pub min_size: Option<LogicalSize>,
+    pub max_size: Option<LogicalSize>,
+
+    pub window_icon: Option<WinIcon>,
+    pub taskbar_icon: Option<WinIcon>,
+
+    pub saved_window: Option<SavedWindow>,
+    pub dpi_factor: f64,
+
+    pub fullscreen: Option<::MonitorId>,
+    window_flags: WindowFlags,
+}
+
+#[derive(Clone)]
+pub struct SavedWindow {
+    pub client_rect: RECT,
+    pub dpi_factor: f64,
+}
+
+#[derive(Clone)]
+pub struct MouseProperties {
+    pub cursor: MouseCursor,
+    cursor_flags: CursorFlags,
+}
+
+bitflags! {
+    pub struct CursorFlags: u8 {
+        const GRABBED   = 1 << 0;
+        const HIDDEN    = 1 << 1;
+        const IN_WINDOW = 1 << 2;
+    }
+}
+bitflags! {
+    pub struct WindowFlags: u32 {
+        const RESIZABLE      = 1 << 0;
+        const DECORATIONS    = 1 << 1;
+        const VISIBLE        = 1 << 2;
+        const ON_TASKBAR     = 1 << 3;
+        const ALWAYS_ON_TOP  = 1 << 4;
+        const NO_BACK_BUFFER = 1 << 5;
+        const TRANSPARENT    = 1 << 6;
+        const CHILD          = 1 << 7;
+        const MAXIMIZED      = 1 << 8;
+
+        /// Marker flag for fullscreen. Should always match `WindowState::fullscreen`, but is
+        /// included here to make masking easier.
+        const MARKER_FULLSCREEN = 1 << 9;
+
+        /// The `WM_SIZE` event contains some parameters that can effect the state of `WindowFlags`.
+        /// In most cases, it's okay to let those parameters change the state. However, when we're
+        /// running the `WindowFlags::apply_diff` function, we *don't* want those parameters to
+        /// effect our stored state, because the purpose of `apply_diff` is to update the actual
+        /// window's state to match our stored state. This controls whether to accept those changes.
+        const MARKER_RETAIN_STATE_ON_SIZE = 1 << 10;
+
+        const FULLSCREEN_AND_MASK = !(
+            WindowFlags::DECORATIONS.bits |
+            WindowFlags::RESIZABLE.bits |
+            WindowFlags::MAXIMIZED.bits
+        );
+        const NO_DECORATIONS_AND_MASK = !WindowFlags::RESIZABLE.bits;
+        const INVISIBLE_AND_MASK = !WindowFlags::MAXIMIZED.bits;
+    }
+}
+
+impl WindowState {
+    pub fn new(
+        attributes: &WindowAttributes,
+        window_icon: Option<WinIcon>,
+        taskbar_icon: Option<WinIcon>,
+        dpi_factor: f64
+    ) -> WindowState {
+        WindowState {
+            mouse: MouseProperties {
+                cursor: MouseCursor::default(),
+                cursor_flags: CursorFlags::empty(),
+            },
+
+            min_size: attributes.min_dimensions,
+            max_size: attributes.max_dimensions,
+
+            window_icon,
+            taskbar_icon,
+
+            saved_window: None,
+            dpi_factor,
+
+            fullscreen: None,
+            window_flags: WindowFlags::empty()
+        }
+    }
+
+    pub fn window_flags(&self) -> WindowFlags {
+        self.window_flags
+    }
+
+    pub fn set_window_flags<F>(mut this: MutexGuard<Self>, window: HWND, set_client_rect: Option<RECT>, f: F)
+        where F: FnOnce(&mut WindowFlags)
+    {
+        let old_flags = this.window_flags;
+        f(&mut this.window_flags);
+
+        let is_fullscreen = this.fullscreen.is_some();
+        this.window_flags.set(WindowFlags::MARKER_FULLSCREEN, is_fullscreen);
+        let new_flags = this.window_flags;
+
+        drop(this);
+        old_flags.apply_diff(window, new_flags, set_client_rect);
+    }
+
+    pub fn refresh_window_state(this: MutexGuard<Self>, window: HWND, set_client_rect: Option<RECT>) {
+        Self::set_window_flags(this, window, set_client_rect, |_| ());
+    }
+
+    pub fn set_window_flags_in_place<F>(&mut self, f: F)
+        where F: FnOnce(&mut WindowFlags)
+    {
+        f(&mut self.window_flags);
+    }
+}
+
+impl MouseProperties {
+    pub fn cursor_flags(&self) -> CursorFlags {
+        self.cursor_flags
+    }
+
+    pub fn set_cursor_flags<F>(&mut self, window: HWND, f: F) -> Result<(), io::Error>
+        where F: FnOnce(&mut CursorFlags)
+    {
+        let old_flags = self.cursor_flags;
+        f(&mut self.cursor_flags);
+        match self.cursor_flags.refresh_os_cursor(window) {
+            Ok(()) => (),
+            Err(e) => {
+                self.cursor_flags = old_flags;
+                return Err(e);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl WindowFlags {
+    fn mask(mut self) -> WindowFlags {
+        if self.contains(WindowFlags::MARKER_FULLSCREEN) {
+            self &= WindowFlags::FULLSCREEN_AND_MASK;
+        }
+        if !self.contains(WindowFlags::VISIBLE) {
+            self &= WindowFlags::INVISIBLE_AND_MASK;
+        }
+        if !self.contains(WindowFlags::DECORATIONS) {
+            self &= WindowFlags::NO_DECORATIONS_AND_MASK;
+        }
+        self
+    }
+
+    pub fn to_window_styles(self) -> (DWORD, DWORD) {
+        use winapi::um::winuser::*;
+
+        let (mut style, mut style_ex) = (0, 0);
+
+        if self.contains(WindowFlags::RESIZABLE) {
+            style |= WS_SIZEBOX | WS_MAXIMIZEBOX;
+        }
+        if self.contains(WindowFlags::DECORATIONS) {
+            style |= WS_CAPTION | WS_MINIMIZEBOX | WS_BORDER;
+            style_ex = WS_EX_WINDOWEDGE;
+        }
+        if self.contains(WindowFlags::VISIBLE) {
+            style |= WS_VISIBLE;
+        }
+        if self.contains(WindowFlags::ON_TASKBAR) {
+            style_ex |= WS_EX_APPWINDOW;
+        }
+        if self.contains(WindowFlags::ALWAYS_ON_TOP) {
+            style_ex |= WS_EX_TOPMOST;
+        }
+        if self.contains(WindowFlags::NO_BACK_BUFFER) {
+            style_ex |= WS_EX_NOREDIRECTIONBITMAP;
+        }
+        if self.contains(WindowFlags::TRANSPARENT) {
+            // Is this necessary? The docs say that WS_EX_LAYERED requires a windows class without
+            // CS_OWNDC, and Winit windows have that flag set.
+            style_ex |= WS_EX_LAYERED;
+        }
+        if self.contains(WindowFlags::CHILD) {
+            style |= WS_CHILD; // This is incompatible with WS_POPUP if that gets added eventually.
+        }
+        if self.contains(WindowFlags::MAXIMIZED) {
+            style |= WS_MAXIMIZE;
+        }
+
+        style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU;
+        style_ex |= WS_EX_ACCEPTFILES;
+
+        (style, style_ex)
+    }
+
+    /// Adjust the window client rectangle to the return value, if present.
+    fn apply_diff(mut self, window: HWND, mut new: WindowFlags, set_client_rect: Option<RECT>) {
+        self = self.mask();
+        new = new.mask();
+
+        let diff = self ^ new;
+        if diff == WindowFlags::empty() {
+            return;
+        }
+
+        if diff.contains(WindowFlags::VISIBLE) {
+            unsafe {
+                winuser::ShowWindow(
+                    window,
+                    match new.contains(WindowFlags::VISIBLE) {
+                        true => winuser::SW_SHOW,
+                        false => winuser::SW_HIDE
+                    }
+                );
+            }
+        }
+        if diff.contains(WindowFlags::ALWAYS_ON_TOP) {
+            unsafe {
+                winuser::SetWindowPos(
+                    window,
+                    match new.contains(WindowFlags::ALWAYS_ON_TOP) {
+                        true  => winuser::HWND_TOPMOST,
+                        false => winuser::HWND_NOTOPMOST,
+                    },
+                    0, 0, 0, 0,
+                    winuser::SWP_ASYNCWINDOWPOS | winuser::SWP_NOMOVE | winuser::SWP_NOSIZE,
+                );
+                winuser::UpdateWindow(window);
+            }
+        }
+
+        if diff.contains(WindowFlags::MAXIMIZED) || new.contains(WindowFlags::MAXIMIZED) {
+            unsafe {
+                winuser::ShowWindow(
+                    window,
+                    match new.contains(WindowFlags::MAXIMIZED) {
+                        true => winuser::SW_MAXIMIZE,
+                        false => winuser::SW_RESTORE
+                    }
+                );
+            }
+        }
+
+        if diff != WindowFlags::empty() {
+            let (style, style_ex) = new.to_window_styles();
+
+            unsafe {
+                winuser::SendMessageW(window, *events_loop::SET_RETAIN_STATE_ON_SIZE_MSG_ID, 1, 0);
+
+                winuser::SetWindowLongW(window, winuser::GWL_STYLE, style as _);
+                winuser::SetWindowLongW(window, winuser::GWL_EXSTYLE, style_ex as _);
+
+                match set_client_rect.and_then(|r| util::adjust_window_rect_with_styles(window, style, style_ex, r)) {
+                    Some(client_rect) => {
+                        let (x, y, w, h) = (
+                            client_rect.left,
+                            client_rect.top,
+                            client_rect.right - client_rect.left,
+                            client_rect.bottom - client_rect.top,
+                        );
+                        winuser::SetWindowPos(
+                            window,
+                            ptr::null_mut(),
+                            x, y, w, h,
+                            winuser::SWP_NOZORDER
+                            | winuser::SWP_FRAMECHANGED,
+                        );
+                    },
+                    None => {
+                        // Refresh the window frame.
+                        winuser::SetWindowPos(
+                            window,
+                            ptr::null_mut(),
+                            0, 0, 0, 0,
+                            winuser::SWP_NOZORDER
+                            | winuser::SWP_NOMOVE
+                            | winuser::SWP_NOSIZE
+                            | winuser::SWP_FRAMECHANGED,
+                        );
+                    }
+                }
+                winuser::SendMessageW(window, *events_loop::SET_RETAIN_STATE_ON_SIZE_MSG_ID, 0, 0);
+            }
+        }
+    }
+}
+
+impl CursorFlags {
+    fn refresh_os_cursor(self, window: HWND) -> Result<(), io::Error> {
+        let client_rect = util::get_client_rect(window)?;
+
+        if util::is_focused(window) {
+            if self.contains(CursorFlags::GRABBED) {
+                util::set_cursor_clip(Some(client_rect))?;
+            } else {
+                util::set_cursor_clip(None)?;
+            }
+        }
+
+        let cursor_in_client = self.contains(CursorFlags::IN_WINDOW);
+        if cursor_in_client {
+            util::set_cursor_hidden(self.contains(CursorFlags::HIDDEN));
+        } else {
+            util::set_cursor_hidden(false);
+        }
+
+        Ok(())
+    }
+}

src/window.rs

@@ -369,6 +369,12 @@ impl Window {
         self.window.set_fullscreen(monitor)
     }
 
+    /// Gets the window's current fullscreen state.
+    #[inline]
+    pub fn get_fullscreen(&self) -> Option<MonitorId> {
+        self.window.get_fullscreen()
+    }
+
     /// Turn window decorations on or off.
     #[inline]
     pub fn set_decorations(&self, decorations: bool) {
@@ -429,6 +435,12 @@ impl Window {
     }
 }
 
+unsafe impl raw_window_handle::HasRawWindowHandle for Window {
+    fn raw_window_handle(&self) -> raw_window_handle::RawWindowHandle {
+        self.window.raw_window_handle()
+    }
+}
+
 /// An iterator for the list of available monitors.
 // Implementation note: we retrieve the list once, then serve each element by one by one.
 // This may change in the future.
@@ -485,7 +497,7 @@ impl MonitorId {
     ///
     /// ## Platform-specific
     ///
-    /// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
+    /// - **X11:** This respects Xft.dpi XResource, and can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
     /// - **Android:** Always returns 1.0.
     #[inline]
     pub fn get_hidpi_factor(&self) -> f64 {