Fix CI and copy wry structure

.changes/config.json

@@ -0,0 +1,84 @@
+{
+  "gitSiteUrl": "https://github.com/tauri-apps/tao/",
+  "timeout": 3600000,
+  "additionalBumpTypes": ["housekeeping"],
+  "pkgManagers": {
+    "rust": {
+      "version": true,
+      "getPublishedVersion": "cargo search ${ pkg.pkg } --limit 1 | sed -nE 's/^[^\"]*\"//; s/\".*//1p'",
+      "prepublish": [
+        "cargo install cargo-audit --features=fix",
+        {
+          "command": "cargo generate-lockfile",
+          "dryRunCommand": true,
+          "runFromRoot": true,
+          "pipe": true
+        },
+        {
+          "command": "echo \"# Cargo Audit\"",
+          "dryRunCommand": true,
+          "pipe": true
+        },
+        {
+          "command": "echo \"\\`\\`\\`\"",
+          "dryRunCommand": true,
+          "pipe": true
+        },
+        {
+          "command": "cargo audit ${ process.env.CARGO_AUDIT_OPTIONS || '' }",
+          "dryRunCommand": true,
+          "runFromRoot": true,
+          "pipe": true
+        },
+        {
+          "command": "echo \"\\`\\`\\`\"",
+          "dryRunCommand": true,
+          "pipe": true
+        }
+      ],
+      "publish": [
+        {
+          "command": "cargo package --allow-dirty",
+          "dryRunCommand": true
+        },
+        {
+          "command": "echo \"# Cargo Publish\"",
+          "dryRunCommand": true,
+          "pipe": true
+        },
+        {
+          "command": "echo \"\\`\\`\\`\"",
+          "dryRunCommand": true,
+          "pipe": true
+        },
+        {
+          "command": "cargo publish --no-verify",
+          "dryRunCommand": "cargo publish --no-verify --dry-run --allow-dirty",
+          "pipe": true
+        },
+        {
+          "command": "echo \"\\`\\`\\`\"",
+          "dryRunCommand": true,
+          "pipe": true
+        }
+      ],
+      "postpublish": [
+        "git tag ${ pkg.pkg }-v${ pkgFile.versionMajor } -f",
+        "git tag ${ pkg.pkg }-v${ pkgFile.versionMajor }.${ pkgFile.versionMinor } -f",
+        "git push --tags -f"
+      ],
+      "assets": [
+        {
+          "path": "${ pkg.path }/${ pkg.pkg }-${ pkgFile.version }.crate",
+          "name": "${ pkg.pkg }-${ pkgFile.version }.crate"
+        }
+      ]
+    }
+  },
+  "packages": {
+    "tao": {
+      "path": "./",
+      "manager": "rust"
+    }
+  }
+}

.github/CODEOWNERS

@@ -0,0 +1,13 @@
+# Current WG Code Sub Teams:
+# @tauri-apps/admins
+# @tauri-apps/core
+# @tauri-apps/testing
+
+# admins default to review
+# Order is important; the last matching pattern takes the most precedence.
+* @tauri-apps/admins 
+
+.github @tauri-apps/admins @tauri-apps/testing
+/examples/ @tauri-apps/testing
+/tests/ @tauri-apps/testing
+/src/ @tauri-apps/core

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

.github/FUNDING.yml

@@ -0,0 +1,8 @@
+# These are supported funding model platforms
+
+github: #
+patreon: #
+open_collective: tauri
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+custom: # Replace with a single custom sponsorship URL

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,8 +1,36 @@
-- [ ] Tested on all platforms changed
-- [ ] Compilation warnings were addressed
-- [ ] `cargo fmt` has been run on this branch
-- [ ] `cargo doc` builds successfully
-- [ ] 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 or updated 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
+<!--
+Please make sure to read the Pull Request Guidelines:
+https://github.com/tauri-apps/tauri/blob/dev/.github/CONTRIBUTING.md#pull-request-guidelines
+-->
+
+<!-- PULL REQUEST TEMPLATE -->
+<!-- (Update "[ ]" to "[x]" to check a box) -->
+
+**What kind of change does this PR introduce?** (check at least one)
+
+- [ ] Bugfix
+- [ ] Feature
+- [ ] Code style update
+- [ ] Refactor
+- [ ] Documentation
+- [ ] Build-related changes
+- [ ] Other, please describe:
+
+**Does this PR introduce a breaking change?** (check one)
+<!--
+If yes, please describe the impact and migration path for existing applications in an attached issue. Filing a PR with breaking changes that has not been discussed and approved by the maintainers in an issue will be immediately closed.
+-->
+
+- [ ] Yes. Issue #___
+- [ ] No
+
+
+**The PR fulfills these requirements:**
+
+- [ ] When resolving a specific issue, it's referenced in the PR's title (e.g. `fix: #xxx[,#xxx]`, where "xxx" is the issue number)
+- [ ] A change file is added if any packages will require a version bump due to this PR per [the instructions in the readme](https://github.com/tauri-apps/tauri/blob/dev/.changes/readme.md).
+
+If adding a **new feature**, the PR's description includes:
+- [ ] A convincing reason for adding this feature (to avoid wasting your time, it's best to open a suggestion issue first and wait for approval before working on it)
+
+**Other information:**

.github/workflows/audit.yml

@@ -0,0 +1,20 @@
+name: Audit
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * *'
+  push:
+    paths:
+      - "Cargo.lock"
+      - "Cargo.toml"
+
+jobs:
+  audit-rust:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: rust audit
+        uses: actions-rs/audit-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yml

@@ -0,0 +1,110 @@
+name: test
+
+on: pull_request
+
+jobs:
+  Check_Formatting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: stable
+          components: rustfmt
+      - name: Check Formatting
+        run: cargo +stable fmt --all -- --check
+
+  Tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_version: [stable, nightly]
+        platform:
+          - { target: x86_64-pc-windows-msvc, os: windows-latest }
+          - { target: i686-pc-windows-msvc, os: windows-latest }
+          - {
+              target: x86_64-pc-windows-gnu,
+              os: windows-latest,
+              host: -x86_64-pc-windows-gnu,
+            }
+          - {
+              target: i686-pc-windows-gnu,
+              os: windows-latest,
+              host: -i686-pc-windows-gnu,
+            }
+          - { target: i686-unknown-linux-gnu, os: ubuntu-latest }
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest }
+          - {
+              target: x86_64-unknown-linux-gnu,
+              os: ubuntu-latest,
+            }
+          - {
+              target: x86_64-unknown-linux-gnu,
+              os: ubuntu-latest,
+            }
+          - { target: aarch64-linux-android, os: ubuntu-latest, cmd: "apk --" }
+          - { target: x86_64-apple-darwin, os: macos-latest }
+          - { target: x86_64-apple-ios, os: macos-latest }
+          - { target: aarch64-apple-ios, os: macos-latest }
+
+    env:
+      RUST_BACKTRACE: 1
+      CARGO_INCREMENTAL: 0
+      RUSTFLAGS: "-C debuginfo=0"
+      OPTIONS: ${{ matrix.platform.options }}
+      FEATURES: ${{ format(',{0}', matrix.platform.features ) }}
+      CMD: ${{ matrix.platform.cmd }}
+
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Cache cargo folder
+        uses: actions/cache@v1
+        with:
+          path: ~/.cargo
+          key: ${{ matrix.platform.target }}-cargo-${{ matrix.rust_version }}
+
+      - uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: ${{ matrix.rust_version }}${{ matrix.platform.host }}
+          targets: ${{ matrix.platform.target }}
+
+      - name: Install GCC Multilib
+        if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
+        run: sudo apt-get update && sudo apt-get install gcc-multilib
+      - name: Install cargo-apk
+        if: contains(matrix.platform.target, 'android')
+        run: cargo install cargo-apk
+
+      - name: Check documentation
+        shell: bash
+        run: cargo $CMD doc --no-deps --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+      - name: Build
+        shell: bash
+        run: cargo $CMD build --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+      - name: Build tests
+        shell: bash
+        run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+      - name: Run tests
+        shell: bash
+        if: (
+          !contains(matrix.platform.target, 'android') &&
+          !contains(matrix.platform.target, 'ios')
+        run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+      - name: Build with serde enabled
+        shell: bash
+        run: cargo $CMD build --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
+
+      - name: Build tests with serde enabled
+        shell: bash
+        run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
+      - name: Run tests with serde enabled
+        shell: bash
+        if: (
+          !contains(matrix.platform.target, 'android') &&
+          !contains(matrix.platform.target, 'ios')
+        run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES

.github/workflows/ci.yml

@@ -1,119 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    paths:
-      - '**.rs'
-      - '**.toml'
-      - '.github/workflows/ci.yml'
-  push:
-    branches: [master]
-    paths:
-      - '**.rs'
-      - '**.toml'
-      - '.github/workflows/ci.yml'
-
-jobs:
-  Check_Formatting:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: hecrj/setup-rust-action@v1
-      with:
-        rust-version: stable
-        components: rustfmt
-    - name: Check Formatting
-      run: cargo +stable fmt --all -- --check
-
-  Tests:
-    strategy:
-      fail-fast: false
-      matrix:
-        rust_version: [stable, nightly]
-        platform:
-          - { target: x86_64-pc-windows-msvc,   os: windows-latest,  }
-          - { target: i686-pc-windows-msvc,     os: windows-latest,  }
-          - { target: x86_64-pc-windows-gnu,    os: windows-latest, host: -x86_64-pc-windows-gnu }
-          - { target: i686-pc-windows-gnu,      os: windows-latest, host: -i686-pc-windows-gnu }
-          - { target: i686-unknown-linux-gnu,   os: ubuntu-latest,   }
-          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
-          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: x11 }
-          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: wayland }
-          - { target: aarch64-linux-android,    os: ubuntu-latest,  cmd: 'apk --' }
-          - { target: x86_64-apple-darwin,      os: macos-latest,    }
-          - { target: x86_64-apple-ios,         os: macos-latest,    }
-          - { target: aarch64-apple-ios,        os: macos-latest,    }
-          # We're using Windows rather than Ubuntu to run the wasm tests because caching cargo-web
-          # doesn't currently work on Linux.
-          - { target: wasm32-unknown-unknown,   os: windows-latest, features: stdweb,  cmd: web }
-          - { target: wasm32-unknown-unknown,   os: windows-latest, features: web-sys, cmd: web }
-
-    env:
-      RUST_BACKTRACE: 1
-      CARGO_INCREMENTAL: 0
-      RUSTFLAGS: "-C debuginfo=0"
-      OPTIONS: ${{ matrix.platform.options }}
-      FEATURES: ${{ format(',{0}', matrix.platform.features ) }}
-      CMD: ${{ matrix.platform.cmd }}
-
-    runs-on: ${{ matrix.platform.os }}
-    steps:
-    - uses: actions/checkout@v2
-    # Used to cache cargo-web
-    - name: Cache cargo folder
-      uses: actions/cache@v1
-      with:
-        path: ~/.cargo
-        key: ${{ matrix.platform.target }}-cargo-${{ matrix.rust_version }}
-
-    - uses: hecrj/setup-rust-action@v1
-      with:
-        rust-version: ${{ matrix.rust_version }}${{ matrix.platform.host }}
-        targets: ${{ matrix.platform.target }}
-
-    - name: Install GCC Multilib
-      if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
-      run: sudo apt-get update && sudo apt-get install gcc-multilib
-    - name: Install cargo-apk
-      if: contains(matrix.platform.target, 'android')
-      run: cargo install cargo-apk
-    - name: Install cargo-web
-      continue-on-error: true
-      if: contains(matrix.platform.target, 'wasm32')
-      run: cargo install cargo-web
-
-    - name: Check documentation
-      shell: bash
-      if: matrix.platform.target != 'wasm32-unknown-unknown'
-      run: cargo $CMD doc --no-deps --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
-
-    - name: Build
-      shell: bash
-      run: cargo $CMD build --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
-
-    - name: Build tests
-      shell: bash
-      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
-    - name: Run tests
-      shell: bash
-      if: (
-        !contains(matrix.platform.target, 'android') &&
-        !contains(matrix.platform.target, 'ios') &&
-        !contains(matrix.platform.target, 'wasm32'))
-      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
-
-
-    - name: Build with serde enabled
-      shell: bash
-      run: cargo $CMD build --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
-
-    - name: Build tests with serde enabled
-      shell: bash
-      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
-    - name: Run tests with serde enabled
-      shell: bash
-      if: (
-        !contains(matrix.platform.target, 'android') &&
-        !contains(matrix.platform.target, 'ios') &&
-        !contains(matrix.platform.target, 'wasm32'))
-      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES

.github/workflows/covector-status.yml

@@ -0,0 +1,16 @@
+name: covector status
+on: [pull_request]
+
+jobs:
+  covector:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: covector status
+        uses: jbolda/covector/packages/action@covector-v0
+        id: covector
+        with:
+          command: 'status'

.github/workflows/covector-version-or-publish.yml

@@ -0,0 +1,46 @@
+name: version or publish
+
+on:
+  push:
+    branches:
+      - dev
+
+jobs:
+  version-or-publish:
+    runs-on: macos-latest
+    timeout-minutes: 65
+    outputs:
+      change: ${{ steps.covector.outputs.change }}
+      commandRan: ${{ steps.covector.outputs.commandRan }}
+      successfulPublish: ${{ steps.covector.outputs.successfulPublish }}
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: cargo login
+        run: cargo login ${{ secrets.CRATE_TOKEN }}
+      - name: git config
+        run: |
+          git config --global user.name "${{ github.event.pusher.name }}"
+          git config --global user.email "${{ github.event.pusher.email }}"
+      - name: covector version or publish (publish when no change files present)
+        uses: jbolda/covector/packages/action@covector-v0
+        id: covector
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          CARGO_AUDIT_OPTIONS: ${{ secrets.CARGO_AUDIT_OPTIONS }}
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          command: 'version-or-publish'
+          createRelease: true
+      - name: Create Pull Request With Versions Bumped
+        id: cpr
+        uses: peter-evans/create-pull-request@v3
+        if: steps.covector.outputs.commandRan == 'version'
+        with:
+          title: "Publish New Versions"
+          commit-message: "publish new versions"
+          labels: "version updates"
+          branch: "release"
+          body: ${{ steps.covector.outputs.change }}

.github/workflows/fmt.yml

@@ -0,0 +1,30 @@
+name: fmt check
+
+on:
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'Cargo.toml'
+
+jobs:
+  clippy_fmt_check:
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+            profile: minimal
+            toolchain: nightly
+            override: true
+            components: rustfmt, clippy
+      - name: clippy check
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-targets -- -D warnings
+      - name: fmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check

.github/workflows/publish.yml

@@ -1,18 +0,0 @@
-name: Publish
-
-on:
-  push:
-    tags:
-    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
-
-jobs:
-  Publish:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: hecrj/setup-rust-action@v1
-      with:
-        rust-version: stable
-        components: rustfmt
-    - name: Publish to crates.io
-      run: cargo publish --token ${{ secrets.cratesio_token }}

.gitignore

@@ -3,7 +3,6 @@ target/
 rls/
 .vscode/
 *~
-*.wasm
 *.ts
 *.js
 #*#

Cargo.toml

@@ -11,7 +11,7 @@ categories = ["gui"]
 [package.metadata.docs.rs]
 features = ["serde"]
 default-target = "x86_64-unknown-linux-gnu"
-targets = ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc", "i686-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "wasm32-unknown-unknown"]
+targets = ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc", "i686-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-apple-darwin"]
 
 [dependencies]
 instant = "0.1"

build.rs

@@ -1,10 +1,10 @@
 fn main() {
-    // If building for macos and WINIT_LINK_COLORSYNC is set to true
-    // use CGDisplayCreateUUIDFromDisplayID from ColorSync instead of CoreGraphics
-    if std::env::var("CARGO_CFG_TARGET_OS").map_or(false, |os| os == "macos")
-        && std::env::var("WINIT_LINK_COLORSYNC")
-            .map_or(false, |v| v == "1" || v.eq_ignore_ascii_case("true"))
-    {
-        println!("cargo:rustc-cfg=use_colorsync_cgdisplaycreateuuidfromdisplayid");
-    }
+  // If building for macos and WINIT_LINK_COLORSYNC is set to true
+  // use CGDisplayCreateUUIDFromDisplayID from ColorSync instead of CoreGraphics
+  if std::env::var("CARGO_CFG_TARGET_OS").map_or(false, |os| os == "macos")
+    && std::env::var("WINIT_LINK_COLORSYNC")
+      .map_or(false, |v| v == "1" || v.eq_ignore_ascii_case("true"))
+  {
+    println!("cargo:rustc-cfg=use_colorsync_cgdisplaycreateuuidfromdisplayid");
+  }
 }

examples/control_flow.rs

@@ -1,114 +1,114 @@
 use std::{thread, time};
 
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, KeyboardInput, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
-    Wait,
-    WaitUntil,
-    Poll,
+  Wait,
+  WaitUntil,
+  Poll,
 }
 
 const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
 const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
+  SimpleLogger::new().init().unwrap();
 
-    println!("Press '1' to switch to Wait mode.");
-    println!("Press '2' to switch to WaitUntil mode.");
-    println!("Press '3' to switch to Poll mode.");
-    println!("Press 'R' to toggle request_redraw() calls.");
-    println!("Press 'Esc' to close the window.");
+  println!("Press '1' to switch to Wait mode.");
+  println!("Press '2' to switch to WaitUntil mode.");
+  println!("Press '3' to switch to Poll mode.");
+  println!("Press 'R' to toggle request_redraw() calls.");
+  println!("Press 'Esc' to close the window.");
 
-    let event_loop = EventLoop::new();
-    let window = WindowBuilder::new()
-        .with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
-        .build(&event_loop)
-        .unwrap();
+  let event_loop = EventLoop::new();
+  let window = WindowBuilder::new()
+    .with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
+    .build(&event_loop)
+    .unwrap();
 
-    let mut mode = Mode::Wait;
-    let mut request_redraw = false;
-    let mut wait_cancelled = false;
-    let mut close_requested = false;
+  let mut mode = Mode::Wait;
+  let mut request_redraw = false;
+  let mut wait_cancelled = false;
+  let mut close_requested = false;
 
-    event_loop.run(move |event, _, control_flow| {
-        use winit::event::{ElementState, StartCause, VirtualKeyCode};
-        println!("{:?}", event);
-        match event {
-            Event::NewEvents(start_cause) => {
-                wait_cancelled = match start_cause {
-                    StartCause::WaitCancelled { .. } => mode == Mode::WaitUntil,
-                    _ => false,
-                }
-            }
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => {
-                    close_requested = true;
-                }
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
-                            state: ElementState::Pressed,
-                            ..
-                        },
-                    ..
-                } => match virtual_code {
-                    VirtualKeyCode::Key1 => {
-                        mode = Mode::Wait;
-                        println!("\nmode: {:?}\n", mode);
-                    }
-                    VirtualKeyCode::Key2 => {
-                        mode = Mode::WaitUntil;
-                        println!("\nmode: {:?}\n", mode);
-                    }
-                    VirtualKeyCode::Key3 => {
-                        mode = Mode::Poll;
-                        println!("\nmode: {:?}\n", mode);
-                    }
-                    VirtualKeyCode::R => {
-                        request_redraw = !request_redraw;
-                        println!("\nrequest_redraw: {}\n", request_redraw);
-                    }
-                    VirtualKeyCode::Escape => {
-                        close_requested = true;
-                    }
-                    _ => (),
-                },
-                _ => (),
-            },
-            Event::MainEventsCleared => {
-                if request_redraw && !wait_cancelled && !close_requested {
-                    window.request_redraw();
-                }
-                if close_requested {
-                    *control_flow = ControlFlow::Exit;
-                }
-            }
-            Event::RedrawRequested(_window_id) => {}
-            Event::RedrawEventsCleared => {
-                *control_flow = match mode {
-                    Mode::Wait => ControlFlow::Wait,
-                    Mode::WaitUntil => {
-                        if wait_cancelled {
-                            *control_flow
-                        } else {
-                            ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME)
-                        }
-                    }
-                    Mode::Poll => {
-                        thread::sleep(POLL_SLEEP_TIME);
-                        ControlFlow::Poll
-                    }
-                };
-            }
-            _ => (),
+  event_loop.run(move |event, _, control_flow| {
+    use tao::event::{ElementState, StartCause, VirtualKeyCode};
+    println!("{:?}", event);
+    match event {
+      Event::NewEvents(start_cause) => {
+        wait_cancelled = match start_cause {
+          StartCause::WaitCancelled { .. } => mode == Mode::WaitUntil,
+          _ => false,
         }
-    });
+      }
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => {
+          close_requested = true;
+        }
+        WindowEvent::KeyboardInput {
+          input:
+            KeyboardInput {
+              virtual_keycode: Some(virtual_code),
+              state: ElementState::Pressed,
+              ..
+            },
+          ..
+        } => match virtual_code {
+          VirtualKeyCode::Key1 => {
+            mode = Mode::Wait;
+            println!("\nmode: {:?}\n", mode);
+          }
+          VirtualKeyCode::Key2 => {
+            mode = Mode::WaitUntil;
+            println!("\nmode: {:?}\n", mode);
+          }
+          VirtualKeyCode::Key3 => {
+            mode = Mode::Poll;
+            println!("\nmode: {:?}\n", mode);
+          }
+          VirtualKeyCode::R => {
+            request_redraw = !request_redraw;
+            println!("\nrequest_redraw: {}\n", request_redraw);
+          }
+          VirtualKeyCode::Escape => {
+            close_requested = true;
+          }
+          _ => (),
+        },
+        _ => (),
+      },
+      Event::MainEventsCleared => {
+        if request_redraw && !wait_cancelled && !close_requested {
+          window.request_redraw();
+        }
+        if close_requested {
+          *control_flow = ControlFlow::Exit;
+        }
+      }
+      Event::RedrawRequested(_window_id) => {}
+      Event::RedrawEventsCleared => {
+        *control_flow = match mode {
+          Mode::Wait => ControlFlow::Wait,
+          Mode::WaitUntil => {
+            if wait_cancelled {
+              *control_flow
+            } else {
+              ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME)
+            }
+          }
+          Mode::Poll => {
+            thread::sleep(POLL_SLEEP_TIME);
+            ControlFlow::Poll
+          }
+        };
+      }
+      _ => (),
+    }
+  });
 }

examples/cursor.rs

@@ -1,89 +1,89 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::{CursorIcon, WindowBuilder},
+use tao::{
+  event::{ElementState, Event, KeyboardInput, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::{CursorIcon, WindowBuilder},
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
-    window.set_title("A fantastic window!");
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
+  window.set_title("A fantastic window!");
 
-    let mut cursor_idx = 0;
+  let mut cursor_idx = 0;
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent {
-                event:
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                state: ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    },
+    match event {
+      Event::WindowEvent {
+        event:
+          WindowEvent::KeyboardInput {
+            input:
+              KeyboardInput {
+                state: ElementState::Pressed,
                 ..
-            } => {
-                println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
-                window.set_cursor_icon(CURSORS[cursor_idx]);
-                if cursor_idx < CURSORS.len() - 1 {
-                    cursor_idx += 1;
-                } else {
-                    cursor_idx = 0;
-                }
-            }
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => {
-                *control_flow = ControlFlow::Exit;
-                return;
-            }
-            _ => (),
+              },
+            ..
+          },
+        ..
+      } => {
+        println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
+        window.set_cursor_icon(CURSORS[cursor_idx]);
+        if cursor_idx < CURSORS.len() - 1 {
+          cursor_idx += 1;
+        } else {
+          cursor_idx = 0;
         }
-    });
+      }
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => {
+        *control_flow = ControlFlow::Exit;
+        return;
+      }
+      _ => (),
+    }
+  });
 }
 
 const CURSORS: &[CursorIcon] = &[
-    CursorIcon::Default,
-    CursorIcon::Crosshair,
-    CursorIcon::Hand,
-    CursorIcon::Arrow,
-    CursorIcon::Move,
-    CursorIcon::Text,
-    CursorIcon::Wait,
-    CursorIcon::Help,
-    CursorIcon::Progress,
-    CursorIcon::NotAllowed,
-    CursorIcon::ContextMenu,
-    CursorIcon::Cell,
-    CursorIcon::VerticalText,
-    CursorIcon::Alias,
-    CursorIcon::Copy,
-    CursorIcon::NoDrop,
-    CursorIcon::Grab,
-    CursorIcon::Grabbing,
-    CursorIcon::AllScroll,
-    CursorIcon::ZoomIn,
-    CursorIcon::ZoomOut,
-    CursorIcon::EResize,
-    CursorIcon::NResize,
-    CursorIcon::NeResize,
-    CursorIcon::NwResize,
-    CursorIcon::SResize,
-    CursorIcon::SeResize,
-    CursorIcon::SwResize,
-    CursorIcon::WResize,
-    CursorIcon::EwResize,
-    CursorIcon::NsResize,
-    CursorIcon::NeswResize,
-    CursorIcon::NwseResize,
-    CursorIcon::ColResize,
-    CursorIcon::RowResize,
+  CursorIcon::Default,
+  CursorIcon::Crosshair,
+  CursorIcon::Hand,
+  CursorIcon::Arrow,
+  CursorIcon::Move,
+  CursorIcon::Text,
+  CursorIcon::Wait,
+  CursorIcon::Help,
+  CursorIcon::Progress,
+  CursorIcon::NotAllowed,
+  CursorIcon::ContextMenu,
+  CursorIcon::Cell,
+  CursorIcon::VerticalText,
+  CursorIcon::Alias,
+  CursorIcon::Copy,
+  CursorIcon::NoDrop,
+  CursorIcon::Grab,
+  CursorIcon::Grabbing,
+  CursorIcon::AllScroll,
+  CursorIcon::ZoomIn,
+  CursorIcon::ZoomOut,
+  CursorIcon::EResize,
+  CursorIcon::NResize,
+  CursorIcon::NeResize,
+  CursorIcon::NwResize,
+  CursorIcon::SResize,
+  CursorIcon::SeResize,
+  CursorIcon::SwResize,
+  CursorIcon::WResize,
+  CursorIcon::EwResize,
+  CursorIcon::NsResize,
+  CursorIcon::NeswResize,
+  CursorIcon::NwseResize,
+  CursorIcon::ColResize,
+  CursorIcon::RowResize,
 ];

examples/cursor_grab.rs

@@ -1,56 +1,56 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("Super Cursor Grab'n'Hide Simulator 9000")
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("Super Cursor Grab'n'Hide Simulator 9000")
+    .build(&event_loop)
+    .unwrap();
 
-    let mut modifiers = ModifiersState::default();
+  let mut modifiers = ModifiersState::default();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            state: ElementState::Released,
-                            virtual_keycode: Some(key),
-                            ..
-                        },
-                    ..
-                } => {
-                    use winit::event::VirtualKeyCode::*;
-                    match key {
-                        Escape => *control_flow = ControlFlow::Exit,
-                        G => window.set_cursor_grab(!modifiers.shift()).unwrap(),
-                        H => window.set_cursor_visible(modifiers.shift()),
-                        _ => (),
-                    }
-                }
-                WindowEvent::ModifiersChanged(m) => modifiers = m,
-                _ => (),
-            },
-            Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseMotion { delta } => println!("mouse moved: {:?}", delta),
-                DeviceEvent::Button { button, state } => match state {
-                    ElementState::Pressed => println!("mouse button {} pressed", button),
-                    ElementState::Released => println!("mouse button {} released", button),
-                },
-                _ => (),
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        WindowEvent::KeyboardInput {
+          input:
+            KeyboardInput {
+              state: ElementState::Released,
+              virtual_keycode: Some(key),
+              ..
             },
+          ..
+        } => {
+          use tao::event::VirtualKeyCode::*;
+          match key {
+            Escape => *control_flow = ControlFlow::Exit,
+            G => window.set_cursor_grab(!modifiers.shift()).unwrap(),
+            H => window.set_cursor_visible(modifiers.shift()),
             _ => (),
+          }
         }
-    });
+        WindowEvent::ModifiersChanged(m) => modifiers = m,
+        _ => (),
+      },
+      Event::DeviceEvent { event, .. } => match event {
+        DeviceEvent::MouseMotion { delta } => println!("mouse moved: {:?}", delta),
+        DeviceEvent::Button { button, state } => match state {
+          ElementState::Pressed => println!("mouse button {} pressed", button),
+          ElementState::Released => println!("mouse button {} released", button),
+        },
+        _ => (),
+      },
+      _ => (),
+    }
+  });
 }

examples/custom_events.rs

@@ -1,53 +1,47 @@
-#[cfg(not(target_arch = "wasm32"))]
 fn main() {
-    use simple_logger::SimpleLogger;
-    use winit::{
-        event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        window::WindowBuilder,
-    };
+  use simple_logger::SimpleLogger;
+  use tao::{
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+  };
 
-    #[derive(Debug, Clone, Copy)]
-    enum CustomEvent {
-        Timer,
+  #[derive(Debug, Clone, Copy)]
+  enum CustomEvent {
+    Timer,
+  }
+
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::<CustomEvent>::with_user_event();
+
+  let _window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
+
+  // `EventLoopProxy` allows you to dispatch custom events to the main Tao event
+  // loop from any thread.
+  let event_loop_proxy = event_loop.create_proxy();
+
+  std::thread::spawn(move || {
+    // Wake up the `event_loop` once every second and dispatch a custom event
+    // from a different thread.
+    loop {
+      std::thread::sleep(std::time::Duration::from_secs(1));
+      event_loop_proxy.send_event(CustomEvent::Timer).ok();
     }
+  });
 
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::<CustomEvent>::with_user_event();
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-    let _window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
-
-    // `EventLoopProxy` allows you to dispatch custom events to the main Winit event
-    // loop from any thread.
-    let event_loop_proxy = event_loop.create_proxy();
-
-    std::thread::spawn(move || {
-        // Wake up the `event_loop` once every second and dispatch a custom event
-        // from a different thread.
-        loop {
-            std::thread::sleep(std::time::Duration::from_secs(1));
-            event_loop_proxy.send_event(CustomEvent::Timer).ok();
-        }
-    });
-
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
-
-        match event {
-            Event::UserEvent(event) => println!("user event: {:?}", event),
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => (),
-        }
-    });
-}
-
-#[cfg(target_arch = "wasm32")]
-fn main() {
-    panic!("This example is not supported on web.");
+    match event {
+      Event::UserEvent(event) => println!("user event: {:?}", event),
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
 }

examples/drag_window.rs

@@ -1,73 +1,73 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{
-        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
-    },
-    event_loop::{ControlFlow, EventLoop},
-    window::{Window, WindowBuilder, WindowId},
+use tao::{
+  event::{
+    ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+  },
+  event_loop::{ControlFlow, EventLoop},
+  window::{Window, WindowBuilder, WindowId},
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
-    let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
+  let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
+  let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
 
-    let mut switched = false;
-    let mut entered_id = window_2.id();
+  let mut switched = false;
+  let mut entered_id = window_2.id();
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::NewEvents(StartCause::Init) => {
-            eprintln!("Switch which window is to be dragged by pressing \"x\".")
-        }
-        Event::WindowEvent { event, window_id } => match event {
-            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-            WindowEvent::MouseInput {
-                state: ElementState::Pressed,
-                button: MouseButton::Left,
-                ..
-            } => {
-                let window = if (window_id == window_1.id() && switched)
-                    || (window_id == window_2.id() && !switched)
-                {
-                    &window_2
-                } else {
-                    &window_1
-                };
+  event_loop.run(move |event, _, control_flow| match event {
+    Event::NewEvents(StartCause::Init) => {
+      eprintln!("Switch which window is to be dragged by pressing \"x\".")
+    }
+    Event::WindowEvent { event, window_id } => match event {
+      WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+      WindowEvent::MouseInput {
+        state: ElementState::Pressed,
+        button: MouseButton::Left,
+        ..
+      } => {
+        let window = if (window_id == window_1.id() && switched)
+          || (window_id == window_2.id() && !switched)
+        {
+          &window_2
+        } else {
+          &window_1
+        };
 
-                window.drag_window().unwrap()
-            }
-            WindowEvent::CursorEntered { .. } => {
-                entered_id = window_id;
-                name_windows(entered_id, switched, &window_1, &window_2)
-            }
-            WindowEvent::KeyboardInput {
-                input:
-                    KeyboardInput {
-                        state: ElementState::Released,
-                        virtual_keycode: Some(VirtualKeyCode::X),
-                        ..
-                    },
-                ..
-            } => {
-                switched = !switched;
-                name_windows(entered_id, switched, &window_1, &window_2);
-                println!("Switched!")
-            }
-            _ => (),
-        },
-        _ => (),
-    });
+        window.drag_window().unwrap()
+      }
+      WindowEvent::CursorEntered { .. } => {
+        entered_id = window_id;
+        name_windows(entered_id, switched, &window_1, &window_2)
+      }
+      WindowEvent::KeyboardInput {
+        input:
+          KeyboardInput {
+            state: ElementState::Released,
+            virtual_keycode: Some(VirtualKeyCode::X),
+            ..
+          },
+        ..
+      } => {
+        switched = !switched;
+        name_windows(entered_id, switched, &window_1, &window_2);
+        println!("Switched!")
+      }
+      _ => (),
+    },
+    _ => (),
+  });
 }
 
 fn name_windows(window_id: WindowId, switched: bool, window_1: &Window, window_2: &Window) {
-    let (drag_target, other) =
-        if (window_id == window_1.id() && switched) || (window_id == window_2.id() && !switched) {
-            (&window_2, &window_1)
-        } else {
-            (&window_1, &window_2)
-        };
-    drag_target.set_title("drag target");
-    other.set_title("winit window");
+  let (drag_target, other) =
+    if (window_id == window_1.id() && switched) || (window_id == window_2.id() && !switched) {
+      (&window_2, &window_1)
+    } else {
+      (&window_1, &window_2)
+    };
+  drag_target.set_title("drag target");
+  other.set_title("winit window");
 }

examples/fullscreen.rs

@@ -1,118 +1,118 @@
 use std::io::{stdin, stdout, Write};
 
 use simple_logger::SimpleLogger;
-use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
-use winit::monitor::{MonitorHandle, VideoMode};
-use winit::window::{Fullscreen, WindowBuilder};
+use tao::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
+use tao::event_loop::{ControlFlow, EventLoop};
+use tao::monitor::{MonitorHandle, VideoMode};
+use tao::window::{Fullscreen, WindowBuilder};
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    print!("Please choose the fullscreen mode: (1) exclusive, (2) borderless: ");
-    stdout().flush().unwrap();
+  print!("Please choose the fullscreen mode: (1) exclusive, (2) borderless: ");
+  stdout().flush().unwrap();
 
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
+  let mut num = String::new();
+  stdin().read_line(&mut num).unwrap();
+  let num = num.trim().parse().ok().expect("Please enter a number");
 
-    let fullscreen = Some(match num {
-        1 => Fullscreen::Exclusive(prompt_for_video_mode(&prompt_for_monitor(&event_loop))),
-        2 => Fullscreen::Borderless(Some(prompt_for_monitor(&event_loop))),
-        _ => panic!("Please enter a valid number"),
-    });
+  let fullscreen = Some(match num {
+    1 => Fullscreen::Exclusive(prompt_for_video_mode(&prompt_for_monitor(&event_loop))),
+    2 => Fullscreen::Borderless(Some(prompt_for_monitor(&event_loop))),
+    _ => panic!("Please enter a valid number"),
+  });
 
-    let mut decorations = true;
+  let mut decorations = true;
 
-    let window = WindowBuilder::new()
-        .with_title("Hello world!")
-        .with_fullscreen(fullscreen.clone())
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("Hello world!")
+    .with_fullscreen(fullscreen.clone())
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
-                            state,
-                            ..
-                        },
-                    ..
-                } => match (virtual_code, state) {
-                    (VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
-                    (VirtualKeyCode::F, ElementState::Pressed) => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
-                        } else {
-                            window.set_fullscreen(fullscreen.clone());
-                        }
-                    }
-                    (VirtualKeyCode::S, ElementState::Pressed) => {
-                        println!("window.fullscreen {:?}", window.fullscreen());
-                    }
-                    (VirtualKeyCode::M, ElementState::Pressed) => {
-                        let is_maximized = window.is_maximized();
-                        window.set_maximized(!is_maximized);
-                    }
-                    (VirtualKeyCode::D, ElementState::Pressed) => {
-                        decorations = !decorations;
-                        window.set_decorations(decorations);
-                    }
-                    _ => (),
-                },
-                _ => (),
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        WindowEvent::KeyboardInput {
+          input:
+            KeyboardInput {
+              virtual_keycode: Some(virtual_code),
+              state,
+              ..
             },
-            _ => {}
-        }
-    });
+          ..
+        } => match (virtual_code, state) {
+          (VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
+          (VirtualKeyCode::F, ElementState::Pressed) => {
+            if window.fullscreen().is_some() {
+              window.set_fullscreen(None);
+            } else {
+              window.set_fullscreen(fullscreen.clone());
+            }
+          }
+          (VirtualKeyCode::S, ElementState::Pressed) => {
+            println!("window.fullscreen {:?}", window.fullscreen());
+          }
+          (VirtualKeyCode::M, ElementState::Pressed) => {
+            let is_maximized = window.is_maximized();
+            window.set_maximized(!is_maximized);
+          }
+          (VirtualKeyCode::D, ElementState::Pressed) => {
+            decorations = !decorations;
+            window.set_decorations(decorations);
+          }
+          _ => (),
+        },
+        _ => (),
+      },
+      _ => {}
+    }
+  });
 }
 
 // Enumerate monitors and prompt user to choose one
 fn prompt_for_monitor(event_loop: &EventLoop<()>) -> MonitorHandle {
-    for (num, monitor) in event_loop.available_monitors().enumerate() {
-        println!("Monitor #{}: {:?}", num, monitor.name());
-    }
+  for (num, monitor) in event_loop.available_monitors().enumerate() {
+    println!("Monitor #{}: {:?}", num, monitor.name());
+  }
 
-    print!("Please write the number of the monitor to use: ");
-    stdout().flush().unwrap();
+  print!("Please write the number of the monitor to use: ");
+  stdout().flush().unwrap();
 
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
-    let monitor = event_loop
-        .available_monitors()
-        .nth(num)
-        .expect("Please enter a valid ID");
+  let mut num = String::new();
+  stdin().read_line(&mut num).unwrap();
+  let num = num.trim().parse().ok().expect("Please enter a number");
+  let monitor = event_loop
+    .available_monitors()
+    .nth(num)
+    .expect("Please enter a valid ID");
 
-    println!("Using {:?}", monitor.name());
+  println!("Using {:?}", monitor.name());
 
-    monitor
+  monitor
 }
 
 fn prompt_for_video_mode(monitor: &MonitorHandle) -> VideoMode {
-    for (i, video_mode) in monitor.video_modes().enumerate() {
-        println!("Video mode #{}: {}", i, video_mode);
-    }
+  for (i, video_mode) in monitor.video_modes().enumerate() {
+    println!("Video mode #{}: {}", i, video_mode);
+  }
 
-    print!("Please write the number of the video mode to use: ");
-    stdout().flush().unwrap();
+  print!("Please write the number of the video mode to use: ");
+  stdout().flush().unwrap();
 
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
-    let video_mode = monitor
-        .video_modes()
-        .nth(num)
-        .expect("Please enter a valid ID");
+  let mut num = String::new();
+  stdin().read_line(&mut num).unwrap();
+  let num = num.trim().parse().ok().expect("Please enter a number");
+  let video_mode = monitor
+    .video_modes()
+    .nth(num)
+    .expect("Please enter a valid ID");
 
-    println!("Using {}", video_mode);
+  println!("Using {}", video_mode);
 
-    video_mode
+  video_mode
 }

examples/handling_close.rs

@@ -1,84 +1,84 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, KeyboardInput, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let _window = WindowBuilder::new()
-        .with_title("Your faithful window")
-        .build(&event_loop)
-        .unwrap();
+  let _window = WindowBuilder::new()
+    .with_title("Your faithful window")
+    .build(&event_loop)
+    .unwrap();
 
-    let mut close_requested = false;
+  let mut close_requested = false;
 
-    event_loop.run(move |event, _, control_flow| {
-        use winit::event::{
-            ElementState::Released,
-            VirtualKeyCode::{N, Y},
-        };
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    use tao::event::{
+      ElementState::Released,
+      VirtualKeyCode::{N, Y},
+    };
+    *control_flow = ControlFlow::Wait;
 
+    match event {
+      Event::WindowEvent { event, .. } => {
         match event {
-            Event::WindowEvent { event, .. } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        // `CloseRequested` is sent when the close button on the window is pressed (or
-                        // through whatever other mechanisms the window manager provides for closing a
-                        // window). If you don't handle this event, the close button won't actually do
-                        // anything.
+          WindowEvent::CloseRequested => {
+            // `CloseRequested` is sent when the close button on the window is pressed (or
+            // through whatever other mechanisms the window manager provides for closing a
+            // window). If you don't handle this event, the close button won't actually do
+            // anything.
 
-                        // A common thing to do here is prompt the user if they have unsaved work.
-                        // Creating a proper dialog box for that is far beyond the scope of this
-                        // example, so here we'll just respond to the Y and N keys.
-                        println!("Are you ready to bid your window farewell? [Y/N]");
-                        close_requested = true;
+            // A common thing to do here is prompt the user if they have unsaved work.
+            // Creating a proper dialog box for that is far beyond the scope of this
+            // example, so here we'll just respond to the Y and N keys.
+            println!("Are you ready to bid your window farewell? [Y/N]");
+            close_requested = true;
 
-                        // In applications where you can safely close the window without further
-                        // action from the user, this is generally where you'd handle cleanup before
-                        // closing the window. How to close the window is detailed in the handler for
-                        // the Y key.
-                    }
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(virtual_code),
-                                state: Released,
-                                ..
-                            },
-                        ..
-                    } => {
-                        match virtual_code {
-                            Y => {
-                                if close_requested {
-                                    // This is where you'll want to do any cleanup you need.
-                                    println!("Buh-bye!");
+            // In applications where you can safely close the window without further
+            // action from the user, this is generally where you'd handle cleanup before
+            // closing the window. How to close the window is detailed in the handler for
+            // the Y key.
+          }
+          WindowEvent::KeyboardInput {
+            input:
+              KeyboardInput {
+                virtual_keycode: Some(virtual_code),
+                state: Released,
+                ..
+              },
+            ..
+          } => {
+            match virtual_code {
+              Y => {
+                if close_requested {
+                  // This is where you'll want to do any cleanup you need.
+                  println!("Buh-bye!");
 
-                                    // For a single-window application like this, you'd normally just
-                                    // break out of the event loop here. If you wanted to keep running the
-                                    // event loop (i.e. if it's a multi-window application), you need to
-                                    // drop the window. That closes it, and results in `Destroyed` being
-                                    // sent.
-                                    *control_flow = ControlFlow::Exit;
-                                }
-                            }
-                            N => {
-                                if close_requested {
-                                    println!("Your window will continue to stay by your side.");
-                                    close_requested = false;
-                                }
-                            }
-                            _ => (),
-                        }
-                    }
-                    _ => (),
+                  // For a single-window application like this, you'd normally just
+                  // break out of the event loop here. If you wanted to keep running the
+                  // event loop (i.e. if it's a multi-window application), you need to
+                  // drop the window. That closes it, and results in `Destroyed` being
+                  // sent.
+                  *control_flow = ControlFlow::Exit;
                 }
+              }
+              N => {
+                if close_requested {
+                  println!("Your window will continue to stay by your side.");
+                  close_requested = false;
+                }
+              }
+              _ => (),
             }
-            _ => (),
+          }
+          _ => (),
         }
-    });
+      }
+      _ => (),
+    }
+  });
 }

examples/min_max_size.rs

@@ -1,30 +1,30 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    dpi::LogicalSize,
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  dpi::LogicalSize,
+  event::{Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
 
-    window.set_min_inner_size(Some(LogicalSize::new(400.0, 200.0)));
-    window.set_max_inner_size(Some(LogicalSize::new(800.0, 400.0)));
+  window.set_min_inner_size(Some(LogicalSize::new(400.0, 200.0)));
+  window.set_max_inner_size(Some(LogicalSize::new(800.0, 400.0)));
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+    println!("{:?}", event);
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
 }

examples/minimize.rs

@@ -1,41 +1,41 @@
-extern crate winit;
+extern crate tao;
 
 use simple_logger::SimpleLogger;
-use winit::event::{Event, VirtualKeyCode, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
-use winit::window::WindowBuilder;
+use tao::event::{Event, VirtualKeyCode, WindowEvent};
+use tao::event_loop::{ControlFlow, EventLoop};
+use tao::window::WindowBuilder;
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
+    match event {
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
 
-            // Keyboard input event to handle minimize via a hotkey
-            Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { input, .. },
-                window_id,
-            } => {
-                if window_id == window.id() {
-                    // Pressing the 'M' key will minimize the window
-                    if input.virtual_keycode == Some(VirtualKeyCode::M) {
-                        window.set_minimized(true);
-                    }
-                }
-            }
-            _ => (),
+      // Keyboard input event to handle minimize via a hotkey
+      Event::WindowEvent {
+        event: WindowEvent::KeyboardInput { input, .. },
+        window_id,
+      } => {
+        if window_id == window.id() {
+          // Pressing the 'M' key will minimize the window
+          if input.virtual_keycode == Some(VirtualKeyCode::M) {
+            window.set_minimized(true);
+          }
         }
-    });
+      }
+      _ => (),
+    }
+  });
 }

examples/monitor_list.rs

@@ -1,11 +1,11 @@
 use simple_logger::SimpleLogger;
-use winit::{event_loop::EventLoop, window::WindowBuilder};
+use tao::{event_loop::EventLoop, window::WindowBuilder};
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
 
-    dbg!(window.available_monitors().collect::<Vec<_>>());
-    dbg!(window.primary_monitor());
+  dbg!(window.available_monitors().collect::<Vec<_>>());
+  dbg!(window.primary_monitor());
 }

examples/mouse_wheel.rs

@@ -1,48 +1,48 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{DeviceEvent, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{DeviceEvent, Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("Mouse Wheel events")
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("Mouse Wheel events")
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                _ => (),
-            },
-            Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseWheel { delta } => match delta {
-                    winit::event::MouseScrollDelta::LineDelta(x, y) => {
-                        println!("mouse wheel Line Delta: ({},{})", x, y);
-                        let pixels_per_line = 120.0;
-                        let mut pos = window.outer_position().unwrap();
-                        pos.x -= (x * pixels_per_line) as i32;
-                        pos.y -= (y * pixels_per_line) as i32;
-                        window.set_outer_position(pos)
-                    }
-                    winit::event::MouseScrollDelta::PixelDelta(p) => {
-                        println!("mouse wheel Pixel Delta: ({},{})", p.x, p.y);
-                        let mut pos = window.outer_position().unwrap();
-                        pos.x -= p.x as i32;
-                        pos.y -= p.y as i32;
-                        window.set_outer_position(pos)
-                    }
-                },
-                _ => (),
-            },
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        _ => (),
+      },
+      Event::DeviceEvent { event, .. } => match event {
+        DeviceEvent::MouseWheel { delta } => match delta {
+          tao::event::MouseScrollDelta::LineDelta(x, y) => {
+            println!("mouse wheel Line Delta: ({},{})", x, y);
+            let pixels_per_line = 120.0;
+            let mut pos = window.outer_position().unwrap();
+            pos.x -= (x * pixels_per_line) as i32;
+            pos.y -= (y * pixels_per_line) as i32;
+            window.set_outer_position(pos)
+          }
+          tao::event::MouseScrollDelta::PixelDelta(p) => {
+            println!("mouse wheel Pixel Delta: ({},{})", p.x, p.y);
+            let mut pos = window.outer_position().unwrap();
+            pos.x -= p.x as i32;
+            pos.y -= p.y as i32;
+            window.set_outer_position(pos)
+          }
+        },
+        _ => (),
+      },
+      _ => (),
+    }
+  });
 }

examples/multithreaded.rs

@@ -1,184 +1,173 @@
-#[cfg(not(target_arch = "wasm32"))]
 fn main() {
-    use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
+  use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
 
-    use simple_logger::SimpleLogger;
-    use winit::{
-        dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-        event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        window::{CursorIcon, Fullscreen, WindowBuilder},
-    };
+  use simple_logger::SimpleLogger;
+  use tao::{
+    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::{CursorIcon, Fullscreen, WindowBuilder},
+  };
 
-    const WINDOW_COUNT: usize = 3;
-    const WINDOW_SIZE: PhysicalSize<u32> = PhysicalSize::new(600, 400);
+  const WINDOW_COUNT: usize = 3;
+  const WINDOW_SIZE: PhysicalSize<u32> = PhysicalSize::new(600, 400);
 
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
-    let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
-    for _ in 0..WINDOW_COUNT {
-        let window = WindowBuilder::new()
-            .with_inner_size(WINDOW_SIZE)
-            .build(&event_loop)
-            .unwrap();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
+  let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
+  for _ in 0..WINDOW_COUNT {
+    let window = WindowBuilder::new()
+      .with_inner_size(WINDOW_SIZE)
+      .build(&event_loop)
+      .unwrap();
 
-        let mut video_modes: Vec<_> = window.current_monitor().unwrap().video_modes().collect();
-        let mut video_mode_id = 0usize;
+    let mut video_modes: Vec<_> = window.current_monitor().unwrap().video_modes().collect();
+    let mut video_mode_id = 0usize;
 
-        let (tx, rx) = mpsc::channel();
-        window_senders.insert(window.id(), tx);
-        thread::spawn(move || {
-            while let Ok(event) = rx.recv() {
-                match event {
-                    WindowEvent::Moved { .. } => {
-                        // We need to update our chosen video mode if the window
-                        // was moved to an another monitor, so that the window
-                        // appears on this monitor instead when we go fullscreen
-                        let previous_video_mode = video_modes.iter().cloned().nth(video_mode_id);
-                        video_modes = window.current_monitor().unwrap().video_modes().collect();
-                        video_mode_id = video_mode_id.min(video_modes.len());
-                        let video_mode = video_modes.iter().nth(video_mode_id);
-
-                        // Different monitors may support different video modes,
-                        // and the index we chose previously may now point to a
-                        // completely different video mode, so notify the user
-                        if video_mode != previous_video_mode.as_ref() {
-                            println!(
-                                "Window moved to another monitor, picked video mode: {}",
-                                video_modes.iter().nth(video_mode_id).unwrap()
-                            );
-                        }
-                    }
-                    #[allow(deprecated)]
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                state: ElementState::Released,
-                                virtual_keycode: Some(key),
-                                modifiers,
-                                ..
-                            },
-                        ..
-                    } => {
-                        window.set_title(&format!("{:?}", key));
-                        let state = !modifiers.shift();
-                        use VirtualKeyCode::*;
-                        match key {
-                            A => window.set_always_on_top(state),
-                            C => window.set_cursor_icon(match state {
-                                true => CursorIcon::Progress,
-                                false => CursorIcon::Default,
-                            }),
-                            D => window.set_decorations(!state),
-                            // Cycle through video modes
-                            Right | Left => {
-                                video_mode_id = match key {
-                                    Left => video_mode_id.saturating_sub(1),
-                                    Right => (video_modes.len() - 1).min(video_mode_id + 1),
-                                    _ => unreachable!(),
-                                };
-                                println!(
-                                    "Picking video mode: {}",
-                                    video_modes.iter().nth(video_mode_id).unwrap()
-                                );
-                            }
-                            F => window.set_fullscreen(match (state, modifiers.alt()) {
-                                (true, false) => Some(Fullscreen::Borderless(None)),
-                                (true, true) => Some(Fullscreen::Exclusive(
-                                    video_modes.iter().nth(video_mode_id).unwrap().clone(),
-                                )),
-                                (false, _) => None,
-                            }),
-                            G => window.set_cursor_grab(state).unwrap(),
-                            H => window.set_cursor_visible(!state),
-                            I => {
-                                println!("Info:");
-                                println!("-> outer_position : {:?}", window.outer_position());
-                                println!("-> inner_position : {:?}", window.inner_position());
-                                println!("-> outer_size     : {:?}", window.outer_size());
-                                println!("-> inner_size     : {:?}", window.inner_size());
-                                println!("-> fullscreen     : {:?}", window.fullscreen());
-                            }
-                            L => window.set_min_inner_size(match state {
-                                true => Some(WINDOW_SIZE),
-                                false => None,
-                            }),
-                            M => window.set_maximized(state),
-                            P => window.set_outer_position({
-                                let mut position = window.outer_position().unwrap();
-                                let sign = if state { 1 } else { -1 };
-                                position.x += 10 * sign;
-                                position.y += 10 * sign;
-                                position
-                            }),
-                            Q => window.request_redraw(),
-                            R => window.set_resizable(state),
-                            S => window.set_inner_size(match state {
-                                true => PhysicalSize::new(
-                                    WINDOW_SIZE.width + 100,
-                                    WINDOW_SIZE.height + 100,
-                                ),
-                                false => WINDOW_SIZE,
-                            }),
-                            W => {
-                                if let Size::Physical(size) = WINDOW_SIZE.into() {
-                                    window
-                                        .set_cursor_position(Position::Physical(
-                                            PhysicalPosition::new(
-                                                size.width as i32 / 2,
-                                                size.height as i32 / 2,
-                                            ),
-                                        ))
-                                        .unwrap()
-                                }
-                            }
-                            Z => {
-                                window.set_visible(false);
-                                thread::sleep(Duration::from_secs(1));
-                                window.set_visible(true);
-                            }
-                            _ => (),
-                        }
-                    }
-                    _ => (),
-                }
-            }
-        });
-    }
-    event_loop.run(move |event, _event_loop, control_flow| {
-        *control_flow = match !window_senders.is_empty() {
-            true => ControlFlow::Wait,
-            false => ControlFlow::Exit,
-        };
+    let (tx, rx) = mpsc::channel();
+    window_senders.insert(window.id(), tx);
+    thread::spawn(move || {
+      while let Ok(event) = rx.recv() {
         match event {
-            Event::WindowEvent { event, window_id } => match event {
-                WindowEvent::CloseRequested
-                | WindowEvent::Destroyed
-                | WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            state: ElementState::Released,
-                            virtual_keycode: Some(VirtualKeyCode::Escape),
-                            ..
-                        },
-                    ..
-                } => {
-                    window_senders.remove(&window_id);
-                }
-                _ => {
-                    if let Some(tx) = window_senders.get(&window_id) {
-                        if let Some(event) = event.to_static() {
-                            tx.send(event).unwrap();
-                        }
-                    }
-                }
-            },
-            _ => (),
-        }
-    })
-}
+          WindowEvent::Moved { .. } => {
+            // We need to update our chosen video mode if the window
+            // was moved to an another monitor, so that the window
+            // appears on this monitor instead when we go fullscreen
+            let previous_video_mode = video_modes.iter().cloned().nth(video_mode_id);
+            video_modes = window.current_monitor().unwrap().video_modes().collect();
+            video_mode_id = video_mode_id.min(video_modes.len());
+            let video_mode = video_modes.iter().nth(video_mode_id);
 
-#[cfg(target_arch = "wasm32")]
-fn main() {
-    panic!("Example not supported on Wasm");
+            // Different monitors may support different video modes,
+            // and the index we chose previously may now point to a
+            // completely different video mode, so notify the user
+            if video_mode != previous_video_mode.as_ref() {
+              println!(
+                "Window moved to another monitor, picked video mode: {}",
+                video_modes.iter().nth(video_mode_id).unwrap()
+              );
+            }
+          }
+          #[allow(deprecated)]
+          WindowEvent::KeyboardInput {
+            input:
+              KeyboardInput {
+                state: ElementState::Released,
+                virtual_keycode: Some(key),
+                modifiers,
+                ..
+              },
+            ..
+          } => {
+            window.set_title(&format!("{:?}", key));
+            let state = !modifiers.shift();
+            use VirtualKeyCode::*;
+            match key {
+              A => window.set_always_on_top(state),
+              C => window.set_cursor_icon(match state {
+                true => CursorIcon::Progress,
+                false => CursorIcon::Default,
+              }),
+              D => window.set_decorations(!state),
+              // Cycle through video modes
+              Right | Left => {
+                video_mode_id = match key {
+                  Left => video_mode_id.saturating_sub(1),
+                  Right => (video_modes.len() - 1).min(video_mode_id + 1),
+                  _ => unreachable!(),
+                };
+                println!(
+                  "Picking video mode: {}",
+                  video_modes.iter().nth(video_mode_id).unwrap()
+                );
+              }
+              F => window.set_fullscreen(match (state, modifiers.alt()) {
+                (true, false) => Some(Fullscreen::Borderless(None)),
+                (true, true) => Some(Fullscreen::Exclusive(
+                  video_modes.iter().nth(video_mode_id).unwrap().clone(),
+                )),
+                (false, _) => None,
+              }),
+              G => window.set_cursor_grab(state).unwrap(),
+              H => window.set_cursor_visible(!state),
+              I => {
+                println!("Info:");
+                println!("-> outer_position : {:?}", window.outer_position());
+                println!("-> inner_position : {:?}", window.inner_position());
+                println!("-> outer_size     : {:?}", window.outer_size());
+                println!("-> inner_size     : {:?}", window.inner_size());
+                println!("-> fullscreen     : {:?}", window.fullscreen());
+              }
+              L => window.set_min_inner_size(match state {
+                true => Some(WINDOW_SIZE),
+                false => None,
+              }),
+              M => window.set_maximized(state),
+              P => window.set_outer_position({
+                let mut position = window.outer_position().unwrap();
+                let sign = if state { 1 } else { -1 };
+                position.x += 10 * sign;
+                position.y += 10 * sign;
+                position
+              }),
+              Q => window.request_redraw(),
+              R => window.set_resizable(state),
+              S => window.set_inner_size(match state {
+                true => PhysicalSize::new(WINDOW_SIZE.width + 100, WINDOW_SIZE.height + 100),
+                false => WINDOW_SIZE,
+              }),
+              W => {
+                if let Size::Physical(size) = WINDOW_SIZE.into() {
+                  window
+                    .set_cursor_position(Position::Physical(PhysicalPosition::new(
+                      size.width as i32 / 2,
+                      size.height as i32 / 2,
+                    )))
+                    .unwrap()
+                }
+              }
+              Z => {
+                window.set_visible(false);
+                thread::sleep(Duration::from_secs(1));
+                window.set_visible(true);
+              }
+              _ => (),
+            }
+          }
+          _ => (),
+        }
+      }
+    });
+  }
+  event_loop.run(move |event, _event_loop, control_flow| {
+    *control_flow = match !window_senders.is_empty() {
+      true => ControlFlow::Wait,
+      false => ControlFlow::Exit,
+    };
+    match event {
+      Event::WindowEvent { event, window_id } => match event {
+        WindowEvent::CloseRequested
+        | WindowEvent::Destroyed
+        | WindowEvent::KeyboardInput {
+          input:
+            KeyboardInput {
+              state: ElementState::Released,
+              virtual_keycode: Some(VirtualKeyCode::Escape),
+              ..
+            },
+          ..
+        } => {
+          window_senders.remove(&window_id);
+        }
+        _ => {
+          if let Some(tx) = window_senders.get(&window_id) {
+            if let Some(event) = event.to_static() {
+              tx.send(event).unwrap();
+            }
+          }
+        }
+      },
+      _ => (),
+    }
+  })
 }

examples/multiwindow.rs

@@ -1,53 +1,53 @@
 use std::collections::HashMap;
 
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::Window,
+use tao::{
+  event::{ElementState, Event, KeyboardInput, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::Window,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let mut windows = HashMap::new();
-    for _ in 0..3 {
-        let window = Window::new(&event_loop).unwrap();
-        windows.insert(window.id(), window);
-    }
+  let mut windows = HashMap::new();
+  for _ in 0..3 {
+    let window = Window::new(&event_loop).unwrap();
+    windows.insert(window.id(), window);
+  }
 
-    event_loop.run(move |event, event_loop, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, event_loop, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
+    match event {
+      Event::WindowEvent { event, window_id } => {
         match event {
-            Event::WindowEvent { event, window_id } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        println!("Window {:?} has received the signal to close", window_id);
+          WindowEvent::CloseRequested => {
+            println!("Window {:?} has received the signal to close", window_id);
 
-                        // This drops the window, causing it to close.
-                        windows.remove(&window_id);
+            // This drops the window, causing it to close.
+            windows.remove(&window_id);
 
-                        if windows.is_empty() {
-                            *control_flow = ControlFlow::Exit;
-                        }
-                    }
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                state: ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    } => {
-                        let window = Window::new(&event_loop).unwrap();
-                        windows.insert(window.id(), window);
-                    }
-                    _ => (),
-                }
+            if windows.is_empty() {
+              *control_flow = ControlFlow::Exit;
             }
-            _ => (),
+          }
+          WindowEvent::KeyboardInput {
+            input:
+              KeyboardInput {
+                state: ElementState::Pressed,
+                ..
+              },
+            ..
+          } => {
+            let window = Window::new(&event_loop).unwrap();
+            windows.insert(window.id(), window);
+          }
+          _ => (),
         }
-    })
+      }
+      _ => (),
+    }
+  })
 }

examples/request_redraw.rs

@@ -1,39 +1,39 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{ElementState, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{ElementState, Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    println!("{:?}", event);
 
-        *control_flow = ControlFlow::Wait;
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::MouseInput {
-                    state: ElementState::Released,
-                    ..
-                } => {
-                    window.request_redraw();
-                }
-                _ => (),
-            },
-            Event::RedrawRequested(_) => {
-                println!("\nredrawing!\n");
-            }
-            _ => (),
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        WindowEvent::MouseInput {
+          state: ElementState::Released,
+          ..
+        } => {
+          window.request_redraw();
         }
-    });
+        _ => (),
+      },
+      Event::RedrawRequested(_) => {
+        println!("\nredrawing!\n");
+      }
+      _ => (),
+    }
+  });
 }

examples/request_redraw_threaded.rs

@@ -1,40 +1,40 @@
 use std::{thread, time};
 
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
 
-    thread::spawn(move || loop {
-        thread::sleep(time::Duration::from_secs(1));
-        window.request_redraw();
-    });
+  thread::spawn(move || loop {
+    thread::sleep(time::Duration::from_secs(1));
+    window.request_redraw();
+  });
 
-    event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    println!("{:?}", event);
 
-        *control_flow = ControlFlow::Wait;
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                _ => (),
-            },
-            Event::RedrawRequested(_) => {
-                println!("\nredrawing!\n");
-            }
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        _ => (),
+      },
+      Event::RedrawRequested(_) => {
+        println!("\nredrawing!\n");
+      }
+      _ => (),
+    }
+  });
 }

examples/resizable.rs

@@ -1,46 +1,46 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    dpi::LogicalSize,
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  dpi::LogicalSize,
+  event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let mut resizable = false;
+  let mut resizable = false;
 
-    let window = WindowBuilder::new()
-        .with_title("Hit space to toggle resizability.")
-        .with_inner_size(LogicalSize::new(400.0, 200.0))
-        .with_resizable(resizable)
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("Hit space to toggle resizability.")
+    .with_inner_size(LogicalSize::new(400.0, 200.0))
+    .with_resizable(resizable)
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(VirtualKeyCode::Space),
-                            state: ElementState::Released,
-                            ..
-                        },
-                    ..
-                } => {
-                    resizable = !resizable;
-                    println!("Resizable: {}", resizable);
-                    window.set_resizable(resizable);
-                }
-                _ => (),
+    match event {
+      Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+        WindowEvent::KeyboardInput {
+          input:
+            KeyboardInput {
+              virtual_keycode: Some(VirtualKeyCode::Space),
+              state: ElementState::Released,
+              ..
             },
-            _ => (),
-        };
-    });
+          ..
+        } => {
+          resizable = !resizable;
+          println!("Resizable: {}", resizable);
+          window.set_resizable(resizable);
+        }
+        _ => (),
+      },
+      _ => (),
+    };
+  });
 }

examples/set_ime_position.rs

@@ -1,54 +1,54 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    dpi::PhysicalPosition,
-    event::{ElementState, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  dpi::PhysicalPosition,
+  event::{ElementState, Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
-    window.set_title("A fantastic window!");
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
+  window.set_title("A fantastic window!");
 
-    println!("Ime position will system default");
-    println!("Click to set ime position to cursor's");
+  println!("Ime position will system default");
+  println!("Click to set ime position to cursor's");
 
-    let mut cursor_position = PhysicalPosition::new(0.0, 0.0);
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  let mut cursor_position = PhysicalPosition::new(0.0, 0.0);
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CursorMoved { position, .. },
-                ..
-            } => {
-                cursor_position = position;
-            }
-            Event::WindowEvent {
-                event:
-                    WindowEvent::MouseInput {
-                        state: ElementState::Released,
-                        ..
-                    },
-                ..
-            } => {
-                println!(
-                    "Setting ime position to {}, {}",
-                    cursor_position.x, cursor_position.y
-                );
-                window.set_ime_position(cursor_position);
-            }
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => {
-                *control_flow = ControlFlow::Exit;
-                return;
-            }
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent {
+        event: WindowEvent::CursorMoved { position, .. },
+        ..
+      } => {
+        cursor_position = position;
+      }
+      Event::WindowEvent {
+        event:
+          WindowEvent::MouseInput {
+            state: ElementState::Released,
+            ..
+          },
+        ..
+      } => {
+        println!(
+          "Setting ime position to {}, {}",
+          cursor_position.x, cursor_position.y
+        );
+        window.set_ime_position(cursor_position);
+      }
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => {
+        *control_flow = ControlFlow::Exit;
+        return;
+      }
+      _ => (),
+    }
+  });
 }

examples/timer.rs

@@ -2,39 +2,39 @@ use instant::Instant;
 use std::time::Duration;
 
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, StartCause, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, StartCause, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let _window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+  let _window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
 
-    let timer_length = Duration::new(1, 0);
+  let timer_length = Duration::new(1, 0);
 
-    event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    println!("{:?}", event);
 
-        match event {
-            Event::NewEvents(StartCause::Init) => {
-                *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length)
-            }
-            Event::NewEvents(StartCause::ResumeTimeReached { .. }) => {
-                *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length);
-                println!("\nTimer\n");
-            }
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => (),
-        }
-    });
+    match event {
+      Event::NewEvents(StartCause::Init) => {
+        *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length)
+      }
+      Event::NewEvents(StartCause::ResumeTimeReached { .. }) => {
+        *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length);
+        println!("\nTimer\n");
+      }
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
 }

examples/transparent.rs

@@ -1,32 +1,32 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_decorations(false)
-        .with_transparent(true)
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_decorations(false)
+    .with_transparent(true)
+    .build(&event_loop)
+    .unwrap();
 
-    window.set_title("A fantastic window!");
+  window.set_title("A fantastic window!");
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+    println!("{:?}", event);
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
 }

examples/video_modes.rs

@@ -1,20 +1,20 @@
 use simple_logger::SimpleLogger;
-use winit::event_loop::EventLoop;
+use tao::event_loop::EventLoop;
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
-    let monitor = match event_loop.primary_monitor() {
-        Some(monitor) => monitor,
-        None => {
-            println!("No primary monitor detected.");
-            return;
-        }
-    };
-
-    println!("Listing available video modes:");
-
-    for mode in monitor.video_modes() {
-        println!("{}", mode);
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
+  let monitor = match event_loop.primary_monitor() {
+    Some(monitor) => monitor,
+    None => {
+      println!("No primary monitor detected.");
+      return;
     }
+  };
+
+  println!("Listing available video modes:");
+
+  for mode in monitor.video_modes() {
+    println!("{}", mode);
+  }
 }

examples/web.rs

@@ -1,74 +0,0 @@
-use winit::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
-};
-
-pub fn main() {
-    let event_loop = EventLoop::new();
-
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
-
-    #[cfg(feature = "web-sys")]
-    {
-        use winit::platform::web::WindowExtWebSys;
-
-        let canvas = window.canvas();
-
-        let window = web_sys::window().unwrap();
-        let document = window.document().unwrap();
-        let body = document.body().unwrap();
-
-        body.append_child(&canvas)
-            .expect("Append canvas to HTML body");
-    }
-
-    #[cfg(feature = "stdweb")]
-    {
-        use std_web::web::INode;
-        use winit::platform::web::WindowExtStdweb;
-
-        let canvas = window.canvas();
-
-        let document = std_web::web::document();
-        let body: std_web::web::Node = document.body().expect("Get HTML body").into();
-
-        body.append_child(&canvas);
-    }
-
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
-
-        #[cfg(feature = "web-sys")]
-        log::debug!("{:?}", event);
-
-        #[cfg(feature = "stdweb")]
-        std_web::console!(log, "%s", format!("{:?}", event));
-
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                window_id,
-            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            Event::MainEventsCleared => {
-                window.request_redraw();
-            }
-            _ => (),
-        }
-    });
-}
-
-#[cfg(feature = "web-sys")]
-mod wasm {
-    use wasm_bindgen::prelude::*;
-
-    #[wasm_bindgen(start)]
-    pub fn run() {
-        console_log::init_with_level(log::Level::Debug);
-
-        super::main();
-    }
-}

examples/window.rs

@@ -1,33 +1,33 @@
 use simple_logger::SimpleLogger;
-use winit::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+use tao::{
+  event::{Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .with_inner_size(tao::dpi::LogicalSize::new(128.0, 128.0))
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
-        println!("{:?}", event);
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+    println!("{:?}", event);
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                window_id,
-            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            Event::MainEventsCleared => {
-                window.request_redraw();
-            }
-            _ => (),
-        }
-    });
+    match event {
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        window_id,
+      } if window_id == window.id() => *control_flow = ControlFlow::Exit,
+      Event::MainEventsCleared => {
+        window.request_redraw();
+      }
+      _ => (),
+    }
+  });
 }

examples/window_debug.rs

@@ -1,125 +1,125 @@
 // This example is used by developers to test various window functions.
 
 use simple_logger::SimpleLogger;
-use winit::{
-    dpi::{LogicalSize, PhysicalSize},
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::{Fullscreen, WindowBuilder},
+use tao::{
+  dpi::{LogicalSize, PhysicalSize},
+  event::{DeviceEvent, ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::{Fullscreen, WindowBuilder},
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new();
+  SimpleLogger::new().init().unwrap();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .with_inner_size(LogicalSize::new(100.0, 100.0))
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .with_inner_size(LogicalSize::new(100.0, 100.0))
+    .build(&event_loop)
+    .unwrap();
 
-    eprintln!("debugging keys:");
-    eprintln!("  (E) Enter exclusive fullscreen");
-    eprintln!("  (F) Toggle borderless fullscreen");
-    eprintln!("  (P) Toggle borderless fullscreen on system's preffered monitor");
-    eprintln!("  (M) Toggle minimized");
-    eprintln!("  (Q) Quit event loop");
-    eprintln!("  (V) Toggle visibility");
-    eprintln!("  (X) Toggle maximized");
+  eprintln!("debugging keys:");
+  eprintln!("  (E) Enter exclusive fullscreen");
+  eprintln!("  (F) Toggle borderless fullscreen");
+  eprintln!("  (P) Toggle borderless fullscreen on system's preffered monitor");
+  eprintln!("  (M) Toggle minimized");
+  eprintln!("  (Q) Quit event loop");
+  eprintln!("  (V) Toggle visibility");
+  eprintln!("  (X) Toggle maximized");
 
-    let mut minimized = false;
-    let mut visible = true;
+  let mut minimized = false;
+  let mut visible = true;
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        match event {
-            Event::DeviceEvent {
-                event:
-                    DeviceEvent::Key(KeyboardInput {
-                        virtual_keycode: Some(key),
-                        state: ElementState::Pressed,
-                        ..
-                    }),
-                ..
-            } => match key {
-                VirtualKeyCode::M => {
-                    if minimized {
-                        minimized = !minimized;
-                        window.set_minimized(minimized);
-                    }
-                }
-                VirtualKeyCode::V => {
-                    if !visible {
-                        visible = !visible;
-                        window.set_visible(visible);
-                    }
-                }
-                _ => (),
-            },
-            Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { input, .. },
-                ..
-            } => match input {
-                KeyboardInput {
-                    virtual_keycode: Some(key),
-                    state: ElementState::Pressed,
-                    ..
-                } => match key {
-                    VirtualKeyCode::E => {
-                        fn area(size: PhysicalSize<u32>) -> u32 {
-                            size.width * size.height
-                        }
-
-                        let monitor = window.current_monitor().unwrap();
-                        if let Some(mode) = monitor
-                            .video_modes()
-                            .max_by(|a, b| area(a.size()).cmp(&area(b.size())))
-                        {
-                            window.set_fullscreen(Some(Fullscreen::Exclusive(mode)));
-                        } else {
-                            eprintln!("no video modes available");
-                        }
-                    }
-                    VirtualKeyCode::F => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
-                        } else {
-                            let monitor = window.current_monitor();
-                            window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
-                        }
-                    }
-                    VirtualKeyCode::P => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
-                        } else {
-                            window.set_fullscreen(Some(Fullscreen::Borderless(None)));
-                        }
-                    }
-                    VirtualKeyCode::M => {
-                        minimized = !minimized;
-                        window.set_minimized(minimized);
-                    }
-                    VirtualKeyCode::Q => {
-                        *control_flow = ControlFlow::Exit;
-                    }
-                    VirtualKeyCode::V => {
-                        visible = !visible;
-                        window.set_visible(visible);
-                    }
-                    VirtualKeyCode::X => {
-                        let is_maximized = window.is_maximized();
-                        window.set_maximized(!is_maximized);
-                    }
-                    _ => (),
-                },
-                _ => (),
-            },
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                window_id,
-            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            _ => (),
+    match event {
+      Event::DeviceEvent {
+        event:
+          DeviceEvent::Key(KeyboardInput {
+            virtual_keycode: Some(key),
+            state: ElementState::Pressed,
+            ..
+          }),
+        ..
+      } => match key {
+        VirtualKeyCode::M => {
+          if minimized {
+            minimized = !minimized;
+            window.set_minimized(minimized);
+          }
         }
-    });
+        VirtualKeyCode::V => {
+          if !visible {
+            visible = !visible;
+            window.set_visible(visible);
+          }
+        }
+        _ => (),
+      },
+      Event::WindowEvent {
+        event: WindowEvent::KeyboardInput { input, .. },
+        ..
+      } => match input {
+        KeyboardInput {
+          virtual_keycode: Some(key),
+          state: ElementState::Pressed,
+          ..
+        } => match key {
+          VirtualKeyCode::E => {
+            fn area(size: PhysicalSize<u32>) -> u32 {
+              size.width * size.height
+            }
+
+            let monitor = window.current_monitor().unwrap();
+            if let Some(mode) = monitor
+              .video_modes()
+              .max_by(|a, b| area(a.size()).cmp(&area(b.size())))
+            {
+              window.set_fullscreen(Some(Fullscreen::Exclusive(mode)));
+            } else {
+              eprintln!("no video modes available");
+            }
+          }
+          VirtualKeyCode::F => {
+            if window.fullscreen().is_some() {
+              window.set_fullscreen(None);
+            } else {
+              let monitor = window.current_monitor();
+              window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
+            }
+          }
+          VirtualKeyCode::P => {
+            if window.fullscreen().is_some() {
+              window.set_fullscreen(None);
+            } else {
+              window.set_fullscreen(Some(Fullscreen::Borderless(None)));
+            }
+          }
+          VirtualKeyCode::M => {
+            minimized = !minimized;
+            window.set_minimized(minimized);
+          }
+          VirtualKeyCode::Q => {
+            *control_flow = ControlFlow::Exit;
+          }
+          VirtualKeyCode::V => {
+            visible = !visible;
+            window.set_visible(visible);
+          }
+          VirtualKeyCode::X => {
+            let is_maximized = window.is_maximized();
+            window.set_maximized(!is_maximized);
+          }
+          _ => (),
+        },
+        _ => (),
+      },
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        window_id,
+      } if window_id == window.id() => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
 }

examples/window_icon.rs

@@ -2,57 +2,57 @@ extern crate image;
 use std::path::Path;
 
 use simple_logger::SimpleLogger;
-use winit::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoop},
-    window::{Icon, WindowBuilder},
+use tao::{
+  event::Event,
+  event_loop::{ControlFlow, EventLoop},
+  window::{Icon, WindowBuilder},
 };
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
+  SimpleLogger::new().init().unwrap();
 
-    // You'll have to choose an icon size at your own discretion. On X11, the desired size varies
-    // by WM, and on Windows, you still have to account for screen scaling. Here we use 32px,
-    // since it seems to work well enough in most cases. Be careful about going too high, or
-    // you'll be bitten by the low-quality downscaling built into the WM.
-    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/icon.png");
+  // You'll have to choose an icon size at your own discretion. On X11, the desired size varies
+  // by WM, and on Windows, you still have to account for screen scaling. Here we use 32px,
+  // since it seems to work well enough in most cases. Be careful about going too high, or
+  // you'll be bitten by the low-quality downscaling built into the WM.
+  let path = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/icon.png");
 
-    let icon = load_icon(Path::new(path));
+  let icon = load_icon(Path::new(path));
 
-    let event_loop = EventLoop::new();
+  let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
-        .with_title("An iconic window!")
-        // At present, this only does anything on Windows and X11, so if you want to save load
-        // time, you can put icon loading behind a function that returns `None` on other platforms.
-        .with_window_icon(Some(icon))
-        .build(&event_loop)
-        .unwrap();
+  let window = WindowBuilder::new()
+    .with_title("An iconic window!")
+    // At present, this only does anything on Windows and X11, so if you want to save load
+    // time, you can put icon loading behind a function that returns `None` on other platforms.
+    .with_window_icon(Some(icon))
+    .build(&event_loop)
+    .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
 
-        if let Event::WindowEvent { event, .. } = event {
-            use winit::event::WindowEvent::*;
-            match event {
-                CloseRequested => *control_flow = ControlFlow::Exit,
-                DroppedFile(path) => {
-                    window.set_window_icon(Some(load_icon(&path)));
-                }
-                _ => (),
-            }
+    if let Event::WindowEvent { event, .. } = event {
+      use tao::event::WindowEvent::*;
+      match event {
+        CloseRequested => *control_flow = ControlFlow::Exit,
+        DroppedFile(path) => {
+          window.set_window_icon(Some(load_icon(&path)));
         }
-    });
+        _ => (),
+      }
+    }
+  });
 }
 
 fn load_icon(path: &Path) -> Icon {
-    let (icon_rgba, icon_width, icon_height) = {
-        let image = image::open(path)
-            .expect("Failed to open icon path")
-            .into_rgba8();
-        let (width, height) = image.dimensions();
-        let rgba = image.into_raw();
-        (rgba, width, height)
-    };
-    Icon::from_rgba(icon_rgba, icon_width, icon_height).expect("Failed to open icon")
+  let (icon_rgba, icon_width, icon_height) = {
+    let image = image::open(path)
+      .expect("Failed to open icon path")
+      .into_rgba8();
+    let (width, height) = image.dimensions();
+    let rgba = image.into_raw();
+    (rgba, width, height)
+  };
+  Icon::from_rgba(icon_rgba, icon_width, icon_height).expect("Failed to open icon")
 }

examples/window_run_return.rs

@@ -1,63 +1,63 @@
 // Limit this example to only compatible platforms.
 #[cfg(any(
-    target_os = "windows",
-    target_os = "macos",
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
+  target_os = "windows",
+  target_os = "macos",
+  target_os = "linux",
+  target_os = "dragonfly",
+  target_os = "freebsd",
+  target_os = "netbsd",
+  target_os = "openbsd"
 ))]
 fn main() {
-    use std::{thread::sleep, time::Duration};
+  use std::{thread::sleep, time::Duration};
 
-    use simple_logger::SimpleLogger;
-    use winit::{
-        event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        platform::run_return::EventLoopExtRunReturn,
-        window::WindowBuilder,
-    };
-    let mut event_loop = EventLoop::new();
+  use simple_logger::SimpleLogger;
+  use tao::{
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    platform::run_return::EventLoopExtRunReturn,
+    window::WindowBuilder,
+  };
+  let mut event_loop = EventLoop::new();
 
-    SimpleLogger::new().init().unwrap();
-    let _window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+  SimpleLogger::new().init().unwrap();
+  let _window = WindowBuilder::new()
+    .with_title("A fantastic window!")
+    .build(&event_loop)
+    .unwrap();
 
-    let mut quit = false;
+  let mut quit = false;
 
-    while !quit {
-        event_loop.run_return(|event, _, control_flow| {
-            *control_flow = ControlFlow::Wait;
+  while !quit {
+    event_loop.run_return(|event, _, control_flow| {
+      *control_flow = ControlFlow::Wait;
 
-            if let Event::WindowEvent { event, .. } = &event {
-                // Print only Window events to reduce noise
-                println!("{:?}", event);
-            }
+      if let Event::WindowEvent { event, .. } = &event {
+        // Print only Window events to reduce noise
+        println!("{:?}", event);
+      }
 
-            match event {
-                Event::WindowEvent {
-                    event: WindowEvent::CloseRequested,
-                    ..
-                } => {
-                    quit = true;
-                }
-                Event::MainEventsCleared => {
-                    *control_flow = ControlFlow::Exit;
-                }
-                _ => (),
-            }
-        });
+      match event {
+        Event::WindowEvent {
+          event: WindowEvent::CloseRequested,
+          ..
+        } => {
+          quit = true;
+        }
+        Event::MainEventsCleared => {
+          *control_flow = ControlFlow::Exit;
+        }
+        _ => (),
+      }
+    });
 
-        // Sleep for 1/60 second to simulate rendering
-        println!("rendering");
-        sleep(Duration::from_millis(16));
-    }
+    // Sleep for 1/60 second to simulate rendering
+    println!("rendering");
+    sleep(Duration::from_millis(16));
+  }
 }
 
-#[cfg(any(target_os = "ios", target_os = "android", target_arch = "wasm32"))]
+#[cfg(any(target_os = "ios", target_os = "android"))]
 fn main() {
-    println!("This platform doesn't support run_return.");
+  println!("This platform doesn't support run_return.");
 }

rustfmt.toml

@@ -1,3 +1,15 @@
-force_explicit_abi=true
-use_field_init_shorthand=true
-# merge_imports=true
+max_width = 100
+hard_tabs = false
+tab_spaces = 2
+newline_style = "Unix"
+use_small_heuristics = "Default"
+reorder_imports = true
+reorder_modules = true
+remove_nested_parens = true
+edition = "2018"
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true
+imports_granularity = "Crate"
+#license_template_path = ".license_template"

src/dpi.rs

@@ -35,7 +35,7 @@
 //!
 //! ### Position and Size types
 //!
-//! Winit's `Physical(Position|Size)` types correspond with the actual pixels on the device, and the
+//! Tao's `Physical(Position|Size)` types correspond with the actual pixels on the device, and the
 //! `Logical(Position|Size)` types correspond to the physical pixels divided by the scale factor.
 //! All of Winit's functions return physical types, but can take either logical or physical
 //! coordinates as input, allowing you to use the most convenient coordinate system for your
@@ -89,9 +89,6 @@
 //!   information.
 //! - **Android:** Scale factors are set by the manufacturer to the value that best suits the
 //!   device, and range from `1.0` to `4.0`. See [this article][android_1] for more information.
-//! - **Web:** The scale factor is the ratio between CSS pixels and the physical device pixels.
-//!   In other words, it is the value of [`window.devicePixelRatio`][web_1]. It is affected by
-//!   both the screen scaling and the browser zoom level and can go below `1.0`.
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
@@ -99,54 +96,53 @@
 //! [apple_1]: https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/Displays/Displays.html
 //! [apple_2]: https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/image-size-and-resolution/
 //! [android_1]: https://developer.android.com/training/multiscreen/screendensities
-//! [web_1]: https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
 
 pub trait Pixel: Copy + Into<f64> {
-    fn from_f64(f: f64) -> Self;
-    fn cast<P: Pixel>(self) -> P {
-        P::from_f64(self.into())
-    }
+  fn from_f64(f: f64) -> Self;
+  fn cast<P: Pixel>(self) -> P {
+    P::from_f64(self.into())
+  }
 }
 
 impl Pixel for u8 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u8
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as u8
+  }
 }
 impl Pixel for u16 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u16
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as u16
+  }
 }
 impl Pixel for u32 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u32
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as u32
+  }
 }
 impl Pixel for i8 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i8
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as i8
+  }
 }
 impl Pixel for i16 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i16
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as i16
+  }
 }
 impl Pixel for i32 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i32
-    }
+  fn from_f64(f: f64) -> Self {
+    f.round() as i32
+  }
 }
 impl Pixel for f32 {
-    fn from_f64(f: f64) -> Self {
-        f as f32
-    }
+  fn from_f64(f: f64) -> Self {
+    f as f32
+  }
 }
 impl Pixel for f64 {
-    fn from_f64(f: f64) -> Self {
-        f
-    }
+  fn from_f64(f: f64) -> Self {
+    f
+  }
 }
 
 /// Checks that the scale factor is a normal positive `f64`.
@@ -156,7 +152,7 @@ impl Pixel for f64 {
 /// otherwise, you risk panics.
 #[inline]
 pub fn validate_scale_factor(scale_factor: f64) -> bool {
-    scale_factor.is_sign_positive() && scale_factor.is_normal()
+  scale_factor.is_sign_positive() && scale_factor.is_normal()
 }
 
 /// A position represented in logical pixels.
@@ -167,339 +163,336 @@ pub fn validate_scale_factor(scale_factor: f64) -> bool {
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalPosition<P> {
-    pub x: P,
-    pub y: P,
+  pub x: P,
+  pub y: P,
 }
 
 impl<P> LogicalPosition<P> {
-    #[inline]
-    pub const fn new(x: P, y: P) -> Self {
-        LogicalPosition { x, y }
-    }
+  #[inline]
+  pub const fn new(x: P, y: P) -> Self {
+    LogicalPosition { x, y }
+  }
 }
 
 impl<P: Pixel> LogicalPosition<P> {
-    #[inline]
-    pub fn from_physical<T: Into<PhysicalPosition<X>>, X: Pixel>(
-        physical: T,
-        scale_factor: f64,
-    ) -> Self {
-        physical.into().to_logical(scale_factor)
-    }
+  #[inline]
+  pub fn from_physical<T: Into<PhysicalPosition<X>>, X: Pixel>(
+    physical: T,
+    scale_factor: f64,
+  ) -> Self {
+    physical.into().to_logical(scale_factor)
+  }
 
-    #[inline]
-    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<X> {
-        assert!(validate_scale_factor(scale_factor));
-        let x = self.x.into() * scale_factor;
-        let y = self.y.into() * scale_factor;
-        PhysicalPosition::new(x, y).cast()
-    }
+  #[inline]
+  pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<X> {
+    assert!(validate_scale_factor(scale_factor));
+    let x = self.x.into() * scale_factor;
+    let y = self.y.into() * scale_factor;
+    PhysicalPosition::new(x, y).cast()
+  }
 
-    #[inline]
-    pub fn cast<X: Pixel>(&self) -> LogicalPosition<X> {
-        LogicalPosition {
-            x: self.x.cast(),
-            y: self.y.cast(),
-        }
+  #[inline]
+  pub fn cast<X: Pixel>(&self) -> LogicalPosition<X> {
+    LogicalPosition {
+      x: self.x.cast(),
+      y: self.y.cast(),
     }
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
-    fn from((x, y): (X, X)) -> LogicalPosition<P> {
-        LogicalPosition::new(x.cast(), y.cast())
-    }
+  fn from((x, y): (X, X)) -> LogicalPosition<P> {
+    LogicalPosition::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<(X, X)> for LogicalPosition<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.x.cast(), self.y.cast())
-    }
+  fn into(self: Self) -> (X, X) {
+    (self.x.cast(), self.y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
-    fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
-        LogicalPosition::new(x.cast(), y.cast())
-    }
+  fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
+    LogicalPosition::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<[X; 2]> for LogicalPosition<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.x.cast(), self.y.cast()]
-    }
+  fn into(self: Self) -> [X; 2] {
+    [self.x.cast(), self.y.cast()]
+  }
 }
 
 /// A position represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalPosition<P> {
-    pub x: P,
-    pub y: P,
+  pub x: P,
+  pub y: P,
 }
 
 impl<P> PhysicalPosition<P> {
-    #[inline]
-    pub const fn new(x: P, y: P) -> Self {
-        PhysicalPosition { x, y }
-    }
+  #[inline]
+  pub const fn new(x: P, y: P) -> Self {
+    PhysicalPosition { x, y }
+  }
 }
 
 impl<P: Pixel> PhysicalPosition<P> {
-    #[inline]
-    pub fn from_logical<T: Into<LogicalPosition<X>>, X: Pixel>(
-        logical: T,
-        scale_factor: f64,
-    ) -> Self {
-        logical.into().to_physical(scale_factor)
-    }
+  #[inline]
+  pub fn from_logical<T: Into<LogicalPosition<X>>, X: Pixel>(
+    logical: T,
+    scale_factor: f64,
+  ) -> Self {
+    logical.into().to_physical(scale_factor)
+  }
 
-    #[inline]
-    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalPosition<X> {
-        assert!(validate_scale_factor(scale_factor));
-        let x = self.x.into() / scale_factor;
-        let y = self.y.into() / scale_factor;
-        LogicalPosition::new(x, y).cast()
-    }
+  #[inline]
+  pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalPosition<X> {
+    assert!(validate_scale_factor(scale_factor));
+    let x = self.x.into() / scale_factor;
+    let y = self.y.into() / scale_factor;
+    LogicalPosition::new(x, y).cast()
+  }
 
-    #[inline]
-    pub fn cast<X: Pixel>(&self) -> PhysicalPosition<X> {
-        PhysicalPosition {
-            x: self.x.cast(),
-            y: self.y.cast(),
-        }
+  #[inline]
+  pub fn cast<X: Pixel>(&self) -> PhysicalPosition<X> {
+    PhysicalPosition {
+      x: self.x.cast(),
+      y: self.y.cast(),
     }
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
-    fn from((x, y): (X, X)) -> PhysicalPosition<P> {
-        PhysicalPosition::new(x.cast(), y.cast())
-    }
+  fn from((x, y): (X, X)) -> PhysicalPosition<P> {
+    PhysicalPosition::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<(X, X)> for PhysicalPosition<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.x.cast(), self.y.cast())
-    }
+  fn into(self: Self) -> (X, X) {
+    (self.x.cast(), self.y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
-    fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
-        PhysicalPosition::new(x.cast(), y.cast())
-    }
+  fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
+    PhysicalPosition::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<[X; 2]> for PhysicalPosition<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.x.cast(), self.y.cast()]
-    }
+  fn into(self: Self) -> [X; 2] {
+    [self.x.cast(), self.y.cast()]
+  }
 }
 
 /// A size represented in logical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalSize<P> {
-    pub width: P,
-    pub height: P,
+  pub width: P,
+  pub height: P,
 }
 
 impl<P> LogicalSize<P> {
-    #[inline]
-    pub const fn new(width: P, height: P) -> Self {
-        LogicalSize { width, height }
-    }
+  #[inline]
+  pub const fn new(width: P, height: P) -> Self {
+    LogicalSize { width, height }
+  }
 }
 
 impl<P: Pixel> LogicalSize<P> {
-    #[inline]
-    pub fn from_physical<T: Into<PhysicalSize<X>>, X: Pixel>(
-        physical: T,
-        scale_factor: f64,
-    ) -> Self {
-        physical.into().to_logical(scale_factor)
-    }
+  #[inline]
+  pub fn from_physical<T: Into<PhysicalSize<X>>, X: Pixel>(physical: T, scale_factor: f64) -> Self {
+    physical.into().to_logical(scale_factor)
+  }
 
-    #[inline]
-    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalSize<X> {
-        assert!(validate_scale_factor(scale_factor));
-        let width = self.width.into() * scale_factor;
-        let height = self.height.into() * scale_factor;
-        PhysicalSize::new(width, height).cast()
-    }
+  #[inline]
+  pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalSize<X> {
+    assert!(validate_scale_factor(scale_factor));
+    let width = self.width.into() * scale_factor;
+    let height = self.height.into() * scale_factor;
+    PhysicalSize::new(width, height).cast()
+  }
 
-    #[inline]
-    pub fn cast<X: Pixel>(&self) -> LogicalSize<X> {
-        LogicalSize {
-            width: self.width.cast(),
-            height: self.height.cast(),
-        }
+  #[inline]
+  pub fn cast<X: Pixel>(&self) -> LogicalSize<X> {
+    LogicalSize {
+      width: self.width.cast(),
+      height: self.height.cast(),
     }
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
-    fn from((x, y): (X, X)) -> LogicalSize<P> {
-        LogicalSize::new(x.cast(), y.cast())
-    }
+  fn from((x, y): (X, X)) -> LogicalSize<P> {
+    LogicalSize::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<(X, X)> for LogicalSize<P> {
-    fn into(self: LogicalSize<P>) -> (X, X) {
-        (self.width.cast(), self.height.cast())
-    }
+  fn into(self: LogicalSize<P>) -> (X, X) {
+    (self.width.cast(), self.height.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
-    fn from([x, y]: [X; 2]) -> LogicalSize<P> {
-        LogicalSize::new(x.cast(), y.cast())
-    }
+  fn from([x, y]: [X; 2]) -> LogicalSize<P> {
+    LogicalSize::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<[X; 2]> for LogicalSize<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.width.cast(), self.height.cast()]
-    }
+  fn into(self: Self) -> [X; 2] {
+    [self.width.cast(), self.height.cast()]
+  }
 }
 
 /// A size represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalSize<P> {
-    pub width: P,
-    pub height: P,
+  pub width: P,
+  pub height: P,
 }
 
 impl<P> PhysicalSize<P> {
-    #[inline]
-    pub const fn new(width: P, height: P) -> Self {
-        PhysicalSize { width, height }
-    }
+  #[inline]
+  pub const fn new(width: P, height: P) -> Self {
+    PhysicalSize { width, height }
+  }
 }
 
 impl<P: Pixel> PhysicalSize<P> {
-    #[inline]
-    pub fn from_logical<T: Into<LogicalSize<X>>, X: Pixel>(logical: T, scale_factor: f64) -> Self {
-        logical.into().to_physical(scale_factor)
-    }
+  #[inline]
+  pub fn from_logical<T: Into<LogicalSize<X>>, X: Pixel>(logical: T, scale_factor: f64) -> Self {
+    logical.into().to_physical(scale_factor)
+  }
 
-    #[inline]
-    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalSize<X> {
-        assert!(validate_scale_factor(scale_factor));
-        let width = self.width.into() / scale_factor;
-        let height = self.height.into() / scale_factor;
-        LogicalSize::new(width, height).cast()
-    }
+  #[inline]
+  pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalSize<X> {
+    assert!(validate_scale_factor(scale_factor));
+    let width = self.width.into() / scale_factor;
+    let height = self.height.into() / scale_factor;
+    LogicalSize::new(width, height).cast()
+  }
 
-    #[inline]
-    pub fn cast<X: Pixel>(&self) -> PhysicalSize<X> {
-        PhysicalSize {
-            width: self.width.cast(),
-            height: self.height.cast(),
-        }
+  #[inline]
+  pub fn cast<X: Pixel>(&self) -> PhysicalSize<X> {
+    PhysicalSize {
+      width: self.width.cast(),
+      height: self.height.cast(),
     }
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
-    fn from((x, y): (X, X)) -> PhysicalSize<P> {
-        PhysicalSize::new(x.cast(), y.cast())
-    }
+  fn from((x, y): (X, X)) -> PhysicalSize<P> {
+    PhysicalSize::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<(X, X)> for PhysicalSize<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.width.cast(), self.height.cast())
-    }
+  fn into(self: Self) -> (X, X) {
+    (self.width.cast(), self.height.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
-    fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
-        PhysicalSize::new(x.cast(), y.cast())
-    }
+  fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
+    PhysicalSize::new(x.cast(), y.cast())
+  }
 }
 
 impl<P: Pixel, X: Pixel> Into<[X; 2]> for PhysicalSize<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.width.cast(), self.height.cast()]
-    }
+  fn into(self: Self) -> [X; 2] {
+    [self.width.cast(), self.height.cast()]
+  }
 }
 
 /// A size that's either physical or logical.
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Size {
-    Physical(PhysicalSize<u32>),
-    Logical(LogicalSize<f64>),
+  Physical(PhysicalSize<u32>),
+  Logical(LogicalSize<f64>),
 }
 
 impl Size {
-    pub fn new<S: Into<Size>>(size: S) -> Size {
-        size.into()
-    }
+  pub fn new<S: Into<Size>>(size: S) -> Size {
+    size.into()
+  }
 
-    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalSize<P> {
-        match *self {
-            Size::Physical(size) => size.to_logical(scale_factor),
-            Size::Logical(size) => size.cast(),
-        }
+  pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalSize<P> {
+    match *self {
+      Size::Physical(size) => size.to_logical(scale_factor),
+      Size::Logical(size) => size.cast(),
     }
+  }
 
-    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalSize<P> {
-        match *self {
-            Size::Physical(size) => size.cast(),
-            Size::Logical(size) => size.to_physical(scale_factor),
-        }
+  pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalSize<P> {
+    match *self {
+      Size::Physical(size) => size.cast(),
+      Size::Logical(size) => size.to_physical(scale_factor),
     }
+  }
 }
 
 impl<P: Pixel> From<PhysicalSize<P>> for Size {
-    #[inline]
-    fn from(size: PhysicalSize<P>) -> Size {
-        Size::Physical(size.cast())
-    }
+  #[inline]
+  fn from(size: PhysicalSize<P>) -> Size {
+    Size::Physical(size.cast())
+  }
 }
 
 impl<P: Pixel> From<LogicalSize<P>> for Size {
-    #[inline]
-    fn from(size: LogicalSize<P>) -> Size {
-        Size::Logical(size.cast())
-    }
+  #[inline]
+  fn from(size: LogicalSize<P>) -> Size {
+    Size::Logical(size.cast())
+  }
 }
 
 /// A position that's either physical or logical.
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Position {
-    Physical(PhysicalPosition<i32>),
-    Logical(LogicalPosition<f64>),
+  Physical(PhysicalPosition<i32>),
+  Logical(LogicalPosition<f64>),
 }
 
 impl Position {
-    pub fn new<S: Into<Position>>(position: S) -> Position {
-        position.into()
-    }
+  pub fn new<S: Into<Position>>(position: S) -> Position {
+    position.into()
+  }
 
-    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalPosition<P> {
-        match *self {
-            Position::Physical(position) => position.to_logical(scale_factor),
-            Position::Logical(position) => position.cast(),
-        }
+  pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalPosition<P> {
+    match *self {
+      Position::Physical(position) => position.to_logical(scale_factor),
+      Position::Logical(position) => position.cast(),
     }
+  }
 
-    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<P> {
-        match *self {
-            Position::Physical(position) => position.cast(),
-            Position::Logical(position) => position.to_physical(scale_factor),
-        }
+  pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<P> {
+    match *self {
+      Position::Physical(position) => position.cast(),
+      Position::Logical(position) => position.to_physical(scale_factor),
     }
+  }
 }
 
 impl<P: Pixel> From<PhysicalPosition<P>> for Position {
-    #[inline]
-    fn from(position: PhysicalPosition<P>) -> Position {
-        Position::Physical(position.cast())
-    }
+  #[inline]
+  fn from(position: PhysicalPosition<P>) -> Position {
+    Position::Physical(position.cast())
+  }
 }
 
 impl<P: Pixel> From<LogicalPosition<P>> for Position {
-    #[inline]
-    fn from(position: LogicalPosition<P>) -> Position {
-        Position::Logical(position.cast())
-    }
+  #[inline]
+  fn from(position: LogicalPosition<P>) -> Position {
+    Position::Logical(position.cast())
+  }
 }

src/error.rs

@@ -5,76 +5,76 @@ use crate::platform_impl;
 /// An error whose cause it outside Winit's control.
 #[derive(Debug)]
 pub enum ExternalError {
-    /// The operation is not supported by the backend.
-    NotSupported(NotSupportedError),
-    /// The OS cannot perform the operation.
-    Os(OsError),
+  /// The operation is not supported by the backend.
+  NotSupported(NotSupportedError),
+  /// The OS cannot perform the operation.
+  Os(OsError),
 }
 
 /// The error type for when the requested operation is not supported by the backend.
 #[derive(Clone)]
 pub struct NotSupportedError {
-    _marker: (),
+  _marker: (),
 }
 
 /// The error type for when the OS cannot perform the requested operation.
 #[derive(Debug)]
 pub struct OsError {
-    line: u32,
-    file: &'static str,
-    error: platform_impl::OsError,
+  line: u32,
+  file: &'static str,
+  error: platform_impl::OsError,
 }
 
 impl NotSupportedError {
-    #[inline]
-    #[allow(dead_code)]
-    pub(crate) fn new() -> NotSupportedError {
-        NotSupportedError { _marker: () }
-    }
+  #[inline]
+  #[allow(dead_code)]
+  pub(crate) fn new() -> NotSupportedError {
+    NotSupportedError { _marker: () }
+  }
 }
 
 impl OsError {
-    #[allow(dead_code)]
-    pub(crate) fn new(line: u32, file: &'static str, error: platform_impl::OsError) -> OsError {
-        OsError { line, file, error }
-    }
+  #[allow(dead_code)]
+  pub(crate) fn new(line: u32, file: &'static str, error: platform_impl::OsError) -> OsError {
+    OsError { line, file, error }
+  }
 }
 
 #[allow(unused_macros)]
 macro_rules! os_error {
-    ($error:expr) => {{
-        crate::error::OsError::new(line!(), file!(), $error)
-    }};
+  ($error:expr) => {{
+    crate::error::OsError::new(line!(), file!(), $error)
+  }};
 }
 
 impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.pad(&format!(
-            "os error at {}:{}: {}",
-            self.file, self.line, self.error
-        ))
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    f.pad(&format!(
+      "os error at {}:{}: {}",
+      self.file, self.line, self.error
+    ))
+  }
 }
 
 impl fmt::Display for ExternalError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            ExternalError::NotSupported(e) => e.fmt(f),
-            ExternalError::Os(e) => e.fmt(f),
-        }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    match self {
+      ExternalError::NotSupported(e) => e.fmt(f),
+      ExternalError::Os(e) => e.fmt(f),
     }
+  }
 }
 
 impl fmt::Debug for NotSupportedError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.debug_struct("NotSupportedError").finish()
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    f.debug_struct("NotSupportedError").finish()
+  }
 }
 
 impl fmt::Display for NotSupportedError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.pad("the requested operation is not supported by Winit")
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    f.pad("the requested operation is not supported by Winit")
+  }
 }
 
 impl error::Error for OsError {}

src/event_loop.rs

@@ -30,8 +30,8 @@ use crate::{event::Event, monitor::MonitorHandle, platform_impl};
 /// `EventLoopProxy` allows you to wake up an `EventLoop` from another thread.
 ///
 pub struct EventLoop<T: 'static> {
-    pub(crate) event_loop: platform_impl::EventLoop<T>,
-    pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
+  pub(crate) event_loop: platform_impl::EventLoop<T>,
+  pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
 }
 
 /// Target that associates windows with an `EventLoop`.
@@ -41,20 +41,20 @@ pub struct EventLoop<T: 'static> {
 /// EventLoop<T>`), so functions that take this as a parameter can also take
 /// `&EventLoop`.
 pub struct EventLoopWindowTarget<T: 'static> {
-    pub(crate) p: platform_impl::EventLoopWindowTarget<T>,
-    pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
+  pub(crate) p: platform_impl::EventLoopWindowTarget<T>,
+  pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
 }
 
 impl<T> fmt::Debug for EventLoop<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("EventLoop { .. }")
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.pad("EventLoop { .. }")
+  }
 }
 
 impl<T> fmt::Debug for EventLoopWindowTarget<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("EventLoopWindowTarget { .. }")
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.pad("EventLoopWindowTarget { .. }")
+  }
 }
 
 /// Set by the user callback given to the `EventLoop::run` method.
@@ -71,155 +71,150 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
 /// [events_cleared]: crate::event::Event::RedrawEventsCleared
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ControlFlow {
-    /// When the current loop iteration finishes, immediately begin a new iteration regardless of
-    /// whether or not new events are available to process.
-    ///
-    /// ## Platform-specific
-    /// - **Web:** Events are queued and usually sent when `requestAnimationFrame` fires but sometimes
-    ///   the events in the queue may be sent before the next `requestAnimationFrame` callback, for
-    ///   example when the scaling of the page has changed. This should be treated as an implementation
-    ///   detail which should not be relied on.
-    Poll,
-    /// When the current loop iteration finishes, suspend the thread until another event arrives.
-    Wait,
-    /// When the current loop iteration finishes, suspend the thread until either another event
-    /// arrives or the given time is reached.
-    WaitUntil(Instant),
-    /// Send a `LoopDestroyed` event and stop the event loop. This variant is *sticky* - once set,
-    /// `control_flow` cannot be changed from `Exit`, and any future attempts to do so will result
-    /// in the `control_flow` parameter being reset to `Exit`.
-    Exit,
+  /// When the current loop iteration finishes, immediately begin a new iteration regardless of
+  /// whether or not new events are available to process.
+  Poll,
+  /// When the current loop iteration finishes, suspend the thread until another event arrives.
+  Wait,
+  /// When the current loop iteration finishes, suspend the thread until either another event
+  /// arrives or the given time is reached.
+  WaitUntil(Instant),
+  /// Send a `LoopDestroyed` event and stop the event loop. This variant is *sticky* - once set,
+  /// `control_flow` cannot be changed from `Exit`, and any future attempts to do so will result
+  /// in the `control_flow` parameter being reset to `Exit`.
+  Exit,
 }
 
 impl Default for ControlFlow {
-    #[inline(always)]
-    fn default() -> ControlFlow {
-        ControlFlow::Poll
-    }
+  #[inline(always)]
+  fn default() -> ControlFlow {
+    ControlFlow::Poll
+  }
 }
 
 impl EventLoop<()> {
-    /// Builds a new event loop with a `()` as the user event type.
-    ///
-    /// ***For cross-platform compatibility, the `EventLoop` must be created on the main thread.***
-    /// Attempting to create the event loop on a different thread will panic. This restriction isn't
-    /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
-    /// porting to platforms that require it. `EventLoopExt::new_any_thread` functions are exposed
-    /// in the relevant `platform` module if the target platform supports creating an event loop on
-    /// any thread.
-    ///
-    /// Usage will result in display backend initialisation, this can be controlled on linux
-    /// using an environment variable `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
-    /// If it is not set, winit will try to connect to a wayland connection, and if it fails will
-    /// fallback on x11. If this variable is set with any other value, winit will panic.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread.
-    pub fn new() -> EventLoop<()> {
-        EventLoop::<()>::with_user_event()
-    }
+  /// Builds a new event loop with a `()` as the user event type.
+  ///
+  /// ***For cross-platform compatibility, the `EventLoop` must be created on the main thread.***
+  /// Attempting to create the event loop on a different thread will panic. This restriction isn't
+  /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
+  /// porting to platforms that require it. `EventLoopExt::new_any_thread` functions are exposed
+  /// in the relevant `platform` module if the target platform supports creating an event loop on
+  /// any thread.
+  ///
+  /// Usage will result in display backend initialisation, this can be controlled on linux
+  /// using an environment variable `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
+  /// If it is not set, winit will try to connect to a wayland connection, and if it fails will
+  /// fallback on x11. If this variable is set with any other value, winit will panic.
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **iOS:** Can only be called on the main thread.
+  pub fn new() -> EventLoop<()> {
+    EventLoop::<()>::with_user_event()
+  }
 }
 
 impl<T> EventLoop<T> {
-    /// Builds a new event loop.
-    ///
-    /// All caveats documented in [`EventLoop::new`] apply to this function.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread.
-    pub fn with_user_event() -> EventLoop<T> {
-        EventLoop {
-            event_loop: platform_impl::EventLoop::new(),
-            _marker: ::std::marker::PhantomData,
-        }
+  /// Builds a new event loop.
+  ///
+  /// All caveats documented in [`EventLoop::new`] apply to this function.
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **iOS:** Can only be called on the main thread.
+  pub fn with_user_event() -> EventLoop<T> {
+    EventLoop {
+      event_loop: platform_impl::EventLoop::new(),
+      _marker: ::std::marker::PhantomData,
     }
+  }
 
-    /// Hijacks the calling thread and initializes the winit event loop with the provided
-    /// closure. Since the closure is `'static`, it must be a `move` closure if it needs to
-    /// access any data from the calling context.
-    ///
-    /// See the [`ControlFlow`] docs for information on how changes to `&mut ControlFlow` impact the
-    /// event loop's behavior.
-    ///
-    /// Any values not passed to this function will *not* be dropped.
-    ///
-    /// [`ControlFlow`]: crate::event_loop::ControlFlow
-    #[inline]
-    pub fn run<F>(self, event_handler: F) -> !
-    where
-        F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
-    {
-        self.event_loop.run(event_handler)
-    }
+  /// Hijacks the calling thread and initializes the winit event loop with the provided
+  /// closure. Since the closure is `'static`, it must be a `move` closure if it needs to
+  /// access any data from the calling context.
+  ///
+  /// See the [`ControlFlow`] docs for information on how changes to `&mut ControlFlow` impact the
+  /// event loop's behavior.
+  ///
+  /// Any values not passed to this function will *not* be dropped.
+  ///
+  /// [`ControlFlow`]: crate::event_loop::ControlFlow
+  #[inline]
+  pub fn run<F>(self, event_handler: F) -> !
+  where
+    F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
+  {
+    self.event_loop.run(event_handler)
+  }
 
-    /// Creates an `EventLoopProxy` that can be used to dispatch user events to the main event loop.
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy {
-            event_loop_proxy: self.event_loop.create_proxy(),
-        }
+  /// Creates an `EventLoopProxy` that can be used to dispatch user events to the main event loop.
+  pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    EventLoopProxy {
+      event_loop_proxy: self.event_loop.create_proxy(),
     }
+  }
 }
 
 impl<T> Deref for EventLoop<T> {
-    type Target = EventLoopWindowTarget<T>;
-    fn deref(&self) -> &EventLoopWindowTarget<T> {
-        self.event_loop.window_target()
-    }
+  type Target = EventLoopWindowTarget<T>;
+  fn deref(&self) -> &EventLoopWindowTarget<T> {
+    self.event_loop.window_target()
+  }
 }
 
 impl<T> EventLoopWindowTarget<T> {
-    /// Returns the list of all the monitors available on the system.
-    #[inline]
-    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
-        self.p
-            .available_monitors()
-            .into_iter()
-            .map(|inner| MonitorHandle { inner })
-    }
+  /// Returns the list of all the monitors available on the system.
+  #[inline]
+  pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+    self
+      .p
+      .available_monitors()
+      .into_iter()
+      .map(|inner| MonitorHandle { inner })
+  }
 
-    /// Returns the primary monitor of the system.
-    ///
-    /// Returns `None` if it can't identify any monitor as a primary one.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Wayland:** Always returns `None`.
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        self.p.primary_monitor()
-    }
+  /// Returns the primary monitor of the system.
+  ///
+  /// Returns `None` if it can't identify any monitor as a primary one.
+  ///
+  /// ## Platform-specific
+  ///
+  /// **Wayland:** Always returns `None`.
+  #[inline]
+  pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+    self.p.primary_monitor()
+  }
 }
 
 /// Used to send custom events to `EventLoop`.
 pub struct EventLoopProxy<T: 'static> {
-    event_loop_proxy: platform_impl::EventLoopProxy<T>,
+  event_loop_proxy: platform_impl::EventLoopProxy<T>,
 }
 
 impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self {
-            event_loop_proxy: self.event_loop_proxy.clone(),
-        }
+  fn clone(&self) -> Self {
+    Self {
+      event_loop_proxy: self.event_loop_proxy.clone(),
     }
+  }
 }
 
 impl<T: 'static> EventLoopProxy<T> {
-    /// Send an event to the `EventLoop` from which this proxy was created. This emits a
-    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
-    /// function.
-    ///
-    /// Returns an `Err` if the associated `EventLoop` no longer exists.
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.event_loop_proxy.send_event(event)
-    }
+  /// Send an event to the `EventLoop` from which this proxy was created. This emits a
+  /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
+  /// function.
+  ///
+  /// Returns an `Err` if the associated `EventLoop` no longer exists.
+  pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+    self.event_loop_proxy.send_event(event)
+  }
 }
 
 impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("EventLoopProxy { .. }")
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.pad("EventLoopProxy { .. }")
+  }
 }
 
 /// The error that is returned when an `EventLoopProxy` attempts to wake up an `EventLoop` that
@@ -228,9 +223,9 @@ impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
 pub struct EventLoopClosed<T>(pub T);
 
 impl<T> fmt::Display for EventLoopClosed<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Tried to wake up a closed `EventLoop`")
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.write_str("Tried to wake up a closed `EventLoop`")
+  }
 }
 
 impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}

src/icon.rs

@@ -4,10 +4,10 @@ use std::{error::Error, fmt, io, mem};
 #[repr(C)]
 #[derive(Debug)]
 pub(crate) struct Pixel {
-    pub(crate) r: u8,
-    pub(crate) g: u8,
-    pub(crate) b: u8,
-    pub(crate) a: u8,
+  pub(crate) r: u8,
+  pub(crate) g: u8,
+  pub(crate) b: u8,
+  pub(crate) a: u8,
 }
 
 pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
@@ -15,24 +15,24 @@ pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
 #[derive(Debug)]
 /// An error produced when using `Icon::from_rgba` with invalid arguments.
 pub enum BadIcon {
-    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
-    /// safely interpreted as 32bpp RGBA pixels.
-    ByteCountNotDivisibleBy4 { byte_count: usize },
-    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
-    /// At least one of your arguments is incorrect.
-    DimensionsVsPixelCount {
-        width: u32,
-        height: u32,
-        width_x_height: usize,
-        pixel_count: usize,
-    },
-    /// Produced when underlying OS functionality failed to create the icon
-    OsError(io::Error),
+  /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
+  /// safely interpreted as 32bpp RGBA pixels.
+  ByteCountNotDivisibleBy4 { byte_count: usize },
+  /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
+  /// At least one of your arguments is incorrect.
+  DimensionsVsPixelCount {
+    width: u32,
+    height: u32,
+    width_x_height: usize,
+    pixel_count: usize,
+  },
+  /// Produced when underlying OS functionality failed to create the icon
+  OsError(io::Error),
 }
 
 impl fmt::Display for BadIcon {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
             BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
                 "The length of the `rgba` argument ({:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
                 byte_count,
@@ -48,20 +48,20 @@ impl fmt::Display for BadIcon {
             ),
             BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {:?}", e),
         }
-    }
+  }
 }
 
 impl Error for BadIcon {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(self)
-    }
+  fn source(&self) -> Option<&(dyn Error + 'static)> {
+    Some(self)
+  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct RgbaIcon {
-    pub(crate) rgba: Vec<u8>,
-    pub(crate) width: u32,
-    pub(crate) height: u32,
+  pub(crate) rgba: Vec<u8>,
+  pub(crate) width: u32,
+  pub(crate) height: u32,
 }
 
 /// For platforms which don't have window icons (e.g. web)
@@ -70,66 +70,66 @@ pub(crate) struct NoIcon;
 
 #[allow(dead_code)] // These are not used on every platform
 mod constructors {
-    use super::*;
+  use super::*;
 
-    impl RgbaIcon {
-        /// Creates an `Icon` from 32bpp RGBA data.
-        ///
-        /// The length of `rgba` must be divisible by 4, and `width * height` must equal
-        /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
-        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-            if rgba.len() % PIXEL_SIZE != 0 {
-                return Err(BadIcon::ByteCountNotDivisibleBy4 {
-                    byte_count: rgba.len(),
-                });
-            }
-            let pixel_count = rgba.len() / PIXEL_SIZE;
-            if pixel_count != (width * height) as usize {
-                Err(BadIcon::DimensionsVsPixelCount {
-                    width,
-                    height,
-                    width_x_height: (width * height) as usize,
-                    pixel_count,
-                })
-            } else {
-                Ok(RgbaIcon {
-                    rgba,
-                    width,
-                    height,
-                })
-            }
-        }
-    }
-
-    impl NoIcon {
-        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-            // Create the rgba icon anyway to validate the input
-            let _ = RgbaIcon::from_rgba(rgba, width, height)?;
-            Ok(NoIcon)
-        }
-    }
-}
-
-/// An icon used for the window titlebar, taskbar, etc.
-#[derive(Clone)]
-pub struct Icon {
-    pub(crate) inner: PlatformIcon,
-}
-
-impl fmt::Debug for Icon {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        fmt::Debug::fmt(&self.inner, formatter)
-    }
-}
-
-impl Icon {
+  impl RgbaIcon {
     /// Creates an `Icon` from 32bpp RGBA data.
     ///
     /// The length of `rgba` must be divisible by 4, and `width * height` must equal
     /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
     pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-        Ok(Icon {
-            inner: PlatformIcon::from_rgba(rgba, width, height)?,
+      if rgba.len() % PIXEL_SIZE != 0 {
+        return Err(BadIcon::ByteCountNotDivisibleBy4 {
+          byte_count: rgba.len(),
+        });
+      }
+      let pixel_count = rgba.len() / PIXEL_SIZE;
+      if pixel_count != (width * height) as usize {
+        Err(BadIcon::DimensionsVsPixelCount {
+          width,
+          height,
+          width_x_height: (width * height) as usize,
+          pixel_count,
         })
+      } else {
+        Ok(RgbaIcon {
+          rgba,
+          width,
+          height,
+        })
+      }
     }
+  }
+
+  impl NoIcon {
+    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+      // Create the rgba icon anyway to validate the input
+      let _ = RgbaIcon::from_rgba(rgba, width, height)?;
+      Ok(NoIcon)
+    }
+  }
+}
+
+/// An icon used for the window titlebar, taskbar, etc.
+#[derive(Clone)]
+pub struct Icon {
+  pub(crate) inner: PlatformIcon,
+}
+
+impl fmt::Debug for Icon {
+  fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    fmt::Debug::fmt(&self.inner, formatter)
+  }
+}
+
+impl Icon {
+  /// Creates an `Icon` from 32bpp RGBA data.
+  ///
+  /// The length of `rgba` must be divisible by 4, and `width * height` must equal
+  /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
+  pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+    Ok(Icon {
+      inner: PlatformIcon::from_rgba(rgba, width, height)?,
+    })
+  }
 }

src/lib.rs

@@ -6,7 +6,7 @@
 //! [`EventLoop::new()`] function.
 //!
 //! ```no_run
-//! use winit::event_loop::EventLoop;
+//! use tao::event_loop::EventLoop;
 //! let event_loop = EventLoop::new();
 //! ```
 //!
@@ -42,7 +42,7 @@
 //!
 //!
 //! ```no_run
-//! use winit::{
+//! use tao::{
 //!     event::{Event, WindowEvent},
 //!     event_loop::{ControlFlow, EventLoop},
 //!     window::WindowBuilder,
@@ -146,8 +146,6 @@ extern crate bitflags;
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[macro_use]
 extern crate objc;
-#[cfg(all(target_arch = "wasm32", feature = "std_web"))]
-extern crate std_web as stdweb;
 
 pub mod dpi;
 #[macro_use]

src/monitor.rs

@@ -10,8 +10,8 @@
 //! [loop_get]: crate::event_loop::EventLoopWindowTarget::available_monitors
 //! [window_get]: crate::window::Window::available_monitors
 use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    platform_impl,
+  dpi::{PhysicalPosition, PhysicalSize},
+  platform_impl,
 };
 
 /// Describes a fullscreen video mode of a monitor.
@@ -22,86 +22,88 @@ use crate::{
 /// [monitor_get]: crate::monitor::MonitorHandle::video_modes
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct VideoMode {
-    pub(crate) video_mode: platform_impl::VideoMode,
+  pub(crate) video_mode: platform_impl::VideoMode,
 }
 
 impl std::fmt::Debug for VideoMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.video_mode.fmt(f)
-    }
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    self.video_mode.fmt(f)
+  }
 }
 
 impl PartialOrd for VideoMode {
-    fn partial_cmp(&self, other: &VideoMode) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
+  fn partial_cmp(&self, other: &VideoMode) -> Option<std::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
 }
 
 impl Ord for VideoMode {
-    fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
-        // TODO: we can impl `Ord` for `PhysicalSize` once we switch from `f32`
-        // to `u32` there
-        let size: (u32, u32) = self.size().into();
-        let other_size: (u32, u32) = other.size().into();
-        self.monitor().cmp(&other.monitor()).then(
-            size.cmp(&other_size)
-                .then(
-                    self.refresh_rate()
-                        .cmp(&other.refresh_rate())
-                        .then(self.bit_depth().cmp(&other.bit_depth())),
-                )
-                .reverse(),
+  fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
+    // TODO: we can impl `Ord` for `PhysicalSize` once we switch from `f32`
+    // to `u32` there
+    let size: (u32, u32) = self.size().into();
+    let other_size: (u32, u32) = other.size().into();
+    self.monitor().cmp(&other.monitor()).then(
+      size
+        .cmp(&other_size)
+        .then(
+          self
+            .refresh_rate()
+            .cmp(&other.refresh_rate())
+            .then(self.bit_depth().cmp(&other.bit_depth())),
         )
-    }
+        .reverse(),
+    )
+  }
 }
 
 impl VideoMode {
-    /// Returns the resolution of this video mode.
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.video_mode.size()
-    }
+  /// Returns the resolution of this video mode.
+  #[inline]
+  pub fn size(&self) -> PhysicalSize<u32> {
+    self.video_mode.size()
+  }
 
-    /// Returns the bit depth of this video mode, as in how many bits you have
-    /// available per color. This is generally 24 bits or 32 bits on modern
-    /// systems, depending on whether the alpha channel is counted or not.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland:** Always returns 32.
-    /// - **iOS:** Always returns 32.
-    #[inline]
-    pub fn bit_depth(&self) -> u16 {
-        self.video_mode.bit_depth()
-    }
+  /// Returns the bit depth of this video mode, as in how many bits you have
+  /// available per color. This is generally 24 bits or 32 bits on modern
+  /// systems, depending on whether the alpha channel is counted or not.
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **Wayland:** Always returns 32.
+  /// - **iOS:** Always returns 32.
+  #[inline]
+  pub fn bit_depth(&self) -> u16 {
+    self.video_mode.bit_depth()
+  }
 
-    /// Returns the refresh rate of this video mode. **Note**: the returned
-    /// refresh rate is an integer approximation, and you shouldn't rely on this
-    /// value to be exact.
-    #[inline]
-    pub fn refresh_rate(&self) -> u16 {
-        self.video_mode.refresh_rate()
-    }
+  /// Returns the refresh rate of this video mode. **Note**: the returned
+  /// refresh rate is an integer approximation, and you shouldn't rely on this
+  /// value to be exact.
+  #[inline]
+  pub fn refresh_rate(&self) -> u16 {
+    self.video_mode.refresh_rate()
+  }
 
-    /// Returns the monitor that this video mode is valid for. Each monitor has
-    /// a separate set of valid video modes.
-    #[inline]
-    pub fn monitor(&self) -> MonitorHandle {
-        self.video_mode.monitor()
-    }
+  /// Returns the monitor that this video mode is valid for. Each monitor has
+  /// a separate set of valid video modes.
+  #[inline]
+  pub fn monitor(&self) -> MonitorHandle {
+    self.video_mode.monitor()
+  }
 }
 
 impl std::fmt::Display for VideoMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}x{} @ {} Hz ({} bpp)",
-            self.size().width,
-            self.size().height,
-            self.refresh_rate(),
-            self.bit_depth()
-        )
-    }
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(
+      f,
+      "{}x{} @ {} Hz ({} bpp)",
+      self.size().width,
+      self.size().height,
+      self.refresh_rate(),
+      self.bit_depth()
+    )
+  }
 }
 
 /// Handle to a monitor.
@@ -111,64 +113,47 @@ impl std::fmt::Display for VideoMode {
 /// [`Window`]: crate::window::Window
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MonitorHandle {
-    pub(crate) inner: platform_impl::MonitorHandle,
+  pub(crate) inner: platform_impl::MonitorHandle,
 }
 
 impl MonitorHandle {
-    /// Returns a human-readable name of the monitor.
-    ///
-    /// Returns `None` if the monitor doesn't exist anymore.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Always returns None
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        self.inner.name()
-    }
+  /// Returns a human-readable name of the monitor.
+  ///
+  /// Returns `None` if the monitor doesn't exist anymore.
+  #[inline]
+  pub fn name(&self) -> Option<String> {
+    self.inner.name()
+  }
 
-    /// Returns the monitor's resolution.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Always returns (0,0)
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.inner.size()
-    }
+  /// Returns the monitor's resolution.
+  #[inline]
+  pub fn size(&self) -> PhysicalSize<u32> {
+    self.inner.size()
+  }
 
-    /// Returns the top-left corner position of the monitor relative to the larger full
-    /// screen area.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Always returns (0,0)
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        self.inner.position()
-    }
+  /// Returns the top-left corner position of the monitor relative to the larger full
+  /// screen area.
+  #[inline]
+  pub fn position(&self) -> PhysicalPosition<i32> {
+    self.inner.position()
+  }
 
-    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
-    ///
-    /// See the [`dpi`](crate::dpi) module for more information.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
-    /// - **Android:** Always returns 1.0.
-    /// - **Web:** Always returns 1.0
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        self.inner.scale_factor()
-    }
+  /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
+  ///
+  /// See the [`dpi`](crate::dpi) module for more information.
+  ///
+  /// ## Platform-specific
+  ///
+  /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
+  /// - **Android:** Always returns 1.0.
+  #[inline]
+  pub fn scale_factor(&self) -> f64 {
+    self.inner.scale_factor()
+  }
 
-    /// Returns all fullscreen video modes supported by this monitor.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Always returns an empty iterator
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.inner.video_modes()
-    }
+  /// Returns all fullscreen video modes supported by this monitor.
+  #[inline]
+  pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+    self.inner.video_modes()
+  }
 }

src/platform/android.rs

@@ -1,8 +1,8 @@
 #![cfg(any(target_os = "android"))]
 
 use crate::{
-    event_loop::{EventLoop, EventLoopWindowTarget},
-    window::{Window, WindowBuilder},
+  event_loop::{EventLoop, EventLoopWindowTarget},
+  window::{Window, WindowBuilder},
 };
 use ndk::configuration::Configuration;
 use ndk_glue::Rect;
@@ -17,19 +17,19 @@ pub trait EventLoopWindowTargetExtAndroid {}
 
 /// Additional methods on `Window` that are specific to Android.
 pub trait WindowExtAndroid {
-    fn content_rect(&self) -> Rect;
+  fn content_rect(&self) -> Rect;
 
-    fn config(&self) -> Configuration;
+  fn config(&self) -> Configuration;
 }
 
 impl WindowExtAndroid for Window {
-    fn content_rect(&self) -> Rect {
-        self.window.content_rect()
-    }
+  fn content_rect(&self) -> Rect {
+    self.window.content_rect()
+  }
 
-    fn config(&self) -> Configuration {
-        self.window.config()
-    }
+  fn config(&self) -> Configuration {
+    self.window.config()
+  }
 }
 
 impl<T> EventLoopWindowTargetExtAndroid for EventLoopWindowTarget<T> {}

src/platform/ios.rs

@@ -3,283 +3,285 @@
 use std::os::raw::c_void;
 
 use crate::{
-    event_loop::EventLoop,
-    monitor::{MonitorHandle, VideoMode},
-    window::{Window, WindowBuilder},
+  event_loop::EventLoop,
+  monitor::{MonitorHandle, VideoMode},
+  window::{Window, WindowBuilder},
 };
 
 /// Additional methods on [`EventLoop`] that are specific to iOS.
 pub trait EventLoopExtIOS {
-    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
-    fn idiom(&self) -> Idiom;
+  /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
+  fn idiom(&self) -> Idiom;
 }
 
 impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
-    fn idiom(&self) -> Idiom {
-        self.event_loop.idiom()
-    }
+  fn idiom(&self) -> Idiom {
+    self.event_loop.idiom()
+  }
 }
 
 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
-    /// Returns a pointer to the [`UIWindow`] that is used by this window.
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    ///
-    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
-    fn ui_window(&self) -> *mut c_void;
+  /// Returns a pointer to the [`UIWindow`] that is used by this window.
+  ///
+  /// The pointer will become invalid when the [`Window`] is destroyed.
+  ///
+  /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+  fn ui_window(&self) -> *mut c_void;
 
-    /// Returns a pointer to the [`UIViewController`] that is used by this window.
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    ///
-    /// [`UIViewController`]: https://developer.apple.com/documentation/uikit/uiviewcontroller?language=objc
-    fn ui_view_controller(&self) -> *mut c_void;
+  /// Returns a pointer to the [`UIViewController`] that is used by this window.
+  ///
+  /// The pointer will become invalid when the [`Window`] is destroyed.
+  ///
+  /// [`UIViewController`]: https://developer.apple.com/documentation/uikit/uiviewcontroller?language=objc
+  fn ui_view_controller(&self) -> *mut c_void;
 
-    /// Returns a pointer to the [`UIView`] that is used by this window.
-    ///
-    /// The pointer will become invalid when the [`Window`] is destroyed.
-    ///
-    /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
-    fn ui_view(&self) -> *mut c_void;
+  /// Returns a pointer to the [`UIView`] that is used by this window.
+  ///
+  /// The pointer will become invalid when the [`Window`] is destroyed.
+  ///
+  /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
+  fn ui_view(&self) -> *mut c_void;
 
-    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
-    ///
-    /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::scale_factor()`].
-    ///
-    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
-    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
-    fn set_scale_factor(&self, scale_factor: f64);
+  /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
+  ///
+  /// The default value is device dependent, and it's recommended GLES or Metal applications set
+  /// this to [`MonitorHandle::scale_factor()`].
+  ///
+  /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+  /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+  fn set_scale_factor(&self, scale_factor: f64);
 
-    /// Sets the valid orientations for the [`Window`].
-    ///
-    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
-    ///
-    /// This changes the value returned by
-    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc),
-    /// and then calls
-    /// [`-[UIViewController attemptRotationToDeviceOrientation]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621400-attemptrotationtodeviceorientati?language=objc).
-    fn set_valid_orientations(&self, valid_orientations: ValidOrientations);
+  /// Sets the valid orientations for the [`Window`].
+  ///
+  /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+  ///
+  /// This changes the value returned by
+  /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc),
+  /// and then calls
+  /// [`-[UIViewController attemptRotationToDeviceOrientation]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621400-attemptrotationtodeviceorientati?language=objc).
+  fn set_valid_orientations(&self, valid_orientations: ValidOrientations);
 
-    /// Sets whether the [`Window`] prefers the home indicator hidden.
-    ///
-    /// The default is to prefer showing the home indicator.
-    ///
-    /// This changes the value returned by
-    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc),
-    /// and then calls
-    /// [`-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc).
-    ///
-    /// This only has an effect on iOS 11.0+.
-    fn set_prefers_home_indicator_hidden(&self, hidden: bool);
+  /// Sets whether the [`Window`] prefers the home indicator hidden.
+  ///
+  /// The default is to prefer showing the home indicator.
+  ///
+  /// This changes the value returned by
+  /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc),
+  /// and then calls
+  /// [`-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc).
+  ///
+  /// This only has an effect on iOS 11.0+.
+  fn set_prefers_home_indicator_hidden(&self, hidden: bool);
 
-    /// Sets the screen edges for which the system gestures will take a lower priority than the
-    /// application's touch handling.
-    ///
-    /// This changes the value returned by
-    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc),
-    /// and then calls
-    /// [`-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc).
-    ///
-    /// This only has an effect on iOS 11.0+.
-    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge);
+  /// Sets the screen edges for which the system gestures will take a lower priority than the
+  /// application's touch handling.
+  ///
+  /// This changes the value returned by
+  /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc),
+  /// and then calls
+  /// [`-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc).
+  ///
+  /// This only has an effect on iOS 11.0+.
+  fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge);
 
-    /// Sets whether the [`Window`] prefers the status bar hidden.
-    ///
-    /// The default is to prefer showing the status bar.
-    ///
-    /// This changes the value returned by
-    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc),
-    /// and then calls
-    /// [`-[UIViewController setNeedsStatusBarAppearanceUpdate]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc).
-    fn set_prefers_status_bar_hidden(&self, hidden: bool);
+  /// Sets whether the [`Window`] prefers the status bar hidden.
+  ///
+  /// The default is to prefer showing the status bar.
+  ///
+  /// This changes the value returned by
+  /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc),
+  /// and then calls
+  /// [`-[UIViewController setNeedsStatusBarAppearanceUpdate]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc).
+  fn set_prefers_status_bar_hidden(&self, hidden: bool);
 }
 
 impl WindowExtIOS for Window {
-    #[inline]
-    fn ui_window(&self) -> *mut c_void {
-        self.window.ui_window() as _
-    }
+  #[inline]
+  fn ui_window(&self) -> *mut c_void {
+    self.window.ui_window() as _
+  }
 
-    #[inline]
-    fn ui_view_controller(&self) -> *mut c_void {
-        self.window.ui_view_controller() as _
-    }
+  #[inline]
+  fn ui_view_controller(&self) -> *mut c_void {
+    self.window.ui_view_controller() as _
+  }
 
-    #[inline]
-    fn ui_view(&self) -> *mut c_void {
-        self.window.ui_view() as _
-    }
+  #[inline]
+  fn ui_view(&self) -> *mut c_void {
+    self.window.ui_view() as _
+  }
 
-    #[inline]
-    fn set_scale_factor(&self, scale_factor: f64) {
-        self.window.set_scale_factor(scale_factor)
-    }
+  #[inline]
+  fn set_scale_factor(&self, scale_factor: f64) {
+    self.window.set_scale_factor(scale_factor)
+  }
 
-    #[inline]
-    fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        self.window.set_valid_orientations(valid_orientations)
-    }
+  #[inline]
+  fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
+    self.window.set_valid_orientations(valid_orientations)
+  }
 
-    #[inline]
-    fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        self.window.set_prefers_home_indicator_hidden(hidden)
-    }
+  #[inline]
+  fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
+    self.window.set_prefers_home_indicator_hidden(hidden)
+  }
 
-    #[inline]
-    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
-        self.window
-            .set_preferred_screen_edges_deferring_system_gestures(edges)
-    }
+  #[inline]
+  fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
+    self
+      .window
+      .set_preferred_screen_edges_deferring_system_gestures(edges)
+  }
 
-    #[inline]
-    fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.window.set_prefers_status_bar_hidden(hidden)
-    }
+  #[inline]
+  fn set_prefers_status_bar_hidden(&self, hidden: bool) {
+    self.window.set_prefers_status_bar_hidden(hidden)
+  }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to iOS.
 pub trait WindowBuilderExtIOS {
-    /// Sets the root view class used by the [`Window`], otherwise a barebones [`UIView`] is provided.
-    ///
-    /// An instance of the class will be initialized by calling [`-[UIView initWithFrame:]`](https://developer.apple.com/documentation/uikit/uiview/1622488-initwithframe?language=objc).
-    ///
-    /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
-    fn with_root_view_class(self, root_view_class: *const c_void) -> WindowBuilder;
+  /// Sets the root view class used by the [`Window`], otherwise a barebones [`UIView`] is provided.
+  ///
+  /// An instance of the class will be initialized by calling [`-[UIView initWithFrame:]`](https://developer.apple.com/documentation/uikit/uiview/1622488-initwithframe?language=objc).
+  ///
+  /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
+  fn with_root_view_class(self, root_view_class: *const c_void) -> WindowBuilder;
 
-    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
-    ///
-    /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::scale_factor()`].
-    ///
-    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
-    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
-    fn with_scale_factor(self, scale_factor: f64) -> WindowBuilder;
+  /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
+  ///
+  /// The default value is device dependent, and it's recommended GLES or Metal applications set
+  /// this to [`MonitorHandle::scale_factor()`].
+  ///
+  /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+  /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+  fn with_scale_factor(self, scale_factor: f64) -> WindowBuilder;
 
-    /// Sets the valid orientations for the [`Window`].
-    ///
-    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
-    ///
-    /// This sets the initial value returned by
-    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc).
-    fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> WindowBuilder;
+  /// Sets the valid orientations for the [`Window`].
+  ///
+  /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+  ///
+  /// This sets the initial value returned by
+  /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc).
+  fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> WindowBuilder;
 
-    /// Sets whether the [`Window`] prefers the home indicator hidden.
-    ///
-    /// The default is to prefer showing the home indicator.
-    ///
-    /// This sets the initial value returned by
-    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc).
-    ///
-    /// This only has an effect on iOS 11.0+.
-    fn with_prefers_home_indicator_hidden(self, hidden: bool) -> WindowBuilder;
+  /// Sets whether the [`Window`] prefers the home indicator hidden.
+  ///
+  /// The default is to prefer showing the home indicator.
+  ///
+  /// This sets the initial value returned by
+  /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc).
+  ///
+  /// This only has an effect on iOS 11.0+.
+  fn with_prefers_home_indicator_hidden(self, hidden: bool) -> WindowBuilder;
 
-    /// Sets the screen edges for which the system gestures will take a lower priority than the
-    /// application's touch handling.
-    ///
-    /// This sets the initial value returned by
-    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc).
-    ///
-    /// This only has an effect on iOS 11.0+.
-    fn with_preferred_screen_edges_deferring_system_gestures(
-        self,
-        edges: ScreenEdge,
-    ) -> WindowBuilder;
+  /// Sets the screen edges for which the system gestures will take a lower priority than the
+  /// application's touch handling.
+  ///
+  /// This sets the initial value returned by
+  /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc).
+  ///
+  /// This only has an effect on iOS 11.0+.
+  fn with_preferred_screen_edges_deferring_system_gestures(
+    self,
+    edges: ScreenEdge,
+  ) -> WindowBuilder;
 
-    /// Sets whether the [`Window`] prefers the status bar hidden.
-    ///
-    /// The default is to prefer showing the status bar.
-    ///
-    /// This sets the initial value returned by
-    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
-    fn with_prefers_status_bar_hidden(self, hidden: bool) -> WindowBuilder;
+  /// Sets whether the [`Window`] prefers the status bar hidden.
+  ///
+  /// The default is to prefer showing the status bar.
+  ///
+  /// This sets the initial value returned by
+  /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
+  fn with_prefers_status_bar_hidden(self, hidden: bool) -> WindowBuilder;
 }
 
 impl WindowBuilderExtIOS for WindowBuilder {
-    #[inline]
-    fn with_root_view_class(mut self, root_view_class: *const c_void) -> WindowBuilder {
-        self.platform_specific.root_view_class = unsafe { &*(root_view_class as *const _) };
-        self
-    }
+  #[inline]
+  fn with_root_view_class(mut self, root_view_class: *const c_void) -> WindowBuilder {
+    self.platform_specific.root_view_class = unsafe { &*(root_view_class as *const _) };
+    self
+  }
 
-    #[inline]
-    fn with_scale_factor(mut self, scale_factor: f64) -> WindowBuilder {
-        self.platform_specific.scale_factor = Some(scale_factor);
-        self
-    }
+  #[inline]
+  fn with_scale_factor(mut self, scale_factor: f64) -> WindowBuilder {
+    self.platform_specific.scale_factor = Some(scale_factor);
+    self
+  }
 
-    #[inline]
-    fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> WindowBuilder {
-        self.platform_specific.valid_orientations = valid_orientations;
-        self
-    }
+  #[inline]
+  fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> WindowBuilder {
+    self.platform_specific.valid_orientations = valid_orientations;
+    self
+  }
 
-    #[inline]
-    fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> WindowBuilder {
-        self.platform_specific.prefers_home_indicator_hidden = hidden;
-        self
-    }
+  #[inline]
+  fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> WindowBuilder {
+    self.platform_specific.prefers_home_indicator_hidden = hidden;
+    self
+  }
 
-    #[inline]
-    fn with_preferred_screen_edges_deferring_system_gestures(
-        mut self,
-        edges: ScreenEdge,
-    ) -> WindowBuilder {
-        self.platform_specific
-            .preferred_screen_edges_deferring_system_gestures = edges;
-        self
-    }
+  #[inline]
+  fn with_preferred_screen_edges_deferring_system_gestures(
+    mut self,
+    edges: ScreenEdge,
+  ) -> WindowBuilder {
+    self
+      .platform_specific
+      .preferred_screen_edges_deferring_system_gestures = edges;
+    self
+  }
 
-    #[inline]
-    fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> WindowBuilder {
-        self.platform_specific.prefers_status_bar_hidden = hidden;
-        self
-    }
+  #[inline]
+  fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> WindowBuilder {
+    self.platform_specific.prefers_status_bar_hidden = hidden;
+    self
+  }
 }
 
 /// Additional methods on [`MonitorHandle`] that are specific to iOS.
 pub trait MonitorHandleExtIOS {
-    /// Returns a pointer to the [`UIScreen`] that is used by this monitor.
-    ///
-    /// [`UIScreen`]: https://developer.apple.com/documentation/uikit/uiscreen?language=objc
-    fn ui_screen(&self) -> *mut c_void;
+  /// Returns a pointer to the [`UIScreen`] that is used by this monitor.
+  ///
+  /// [`UIScreen`]: https://developer.apple.com/documentation/uikit/uiscreen?language=objc
+  fn ui_screen(&self) -> *mut c_void;
 
-    /// Returns the preferred [`VideoMode`] for this monitor.
-    ///
-    /// This translates to a call to [`-[UIScreen preferredMode]`](https://developer.apple.com/documentation/uikit/uiscreen/1617823-preferredmode?language=objc).
-    fn preferred_video_mode(&self) -> VideoMode;
+  /// Returns the preferred [`VideoMode`] for this monitor.
+  ///
+  /// This translates to a call to [`-[UIScreen preferredMode]`](https://developer.apple.com/documentation/uikit/uiscreen/1617823-preferredmode?language=objc).
+  fn preferred_video_mode(&self) -> VideoMode;
 }
 
 impl MonitorHandleExtIOS for MonitorHandle {
-    #[inline]
-    fn ui_screen(&self) -> *mut c_void {
-        self.inner.ui_screen() as _
-    }
+  #[inline]
+  fn ui_screen(&self) -> *mut c_void {
+    self.inner.ui_screen() as _
+  }
 
-    #[inline]
-    fn preferred_video_mode(&self) -> VideoMode {
-        self.inner.preferred_video_mode()
-    }
+  #[inline]
+  fn preferred_video_mode(&self) -> VideoMode {
+    self.inner.preferred_video_mode()
+  }
 }
 
 /// Valid orientations for a particular [`Window`].
 #[derive(Clone, Copy, Debug)]
 pub enum ValidOrientations {
-    /// Excludes `PortraitUpsideDown` on iphone
-    LandscapeAndPortrait,
+  /// Excludes `PortraitUpsideDown` on iphone
+  LandscapeAndPortrait,
 
-    Landscape,
+  Landscape,
 
-    /// Excludes `PortraitUpsideDown` on iphone
-    Portrait,
+  /// Excludes `PortraitUpsideDown` on iphone
+  Portrait,
 }
 
 impl Default for ValidOrientations {
-    #[inline]
-    fn default() -> ValidOrientations {
-        ValidOrientations::LandscapeAndPortrait
-    }
+  #[inline]
+  fn default() -> ValidOrientations {
+    ValidOrientations::LandscapeAndPortrait
+  }
 }
 
 /// The device [idiom].
@@ -287,17 +289,17 @@ impl Default for ValidOrientations {
 /// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Idiom {
-    Unspecified,
+  Unspecified,
 
-    /// iPhone and iPod touch.
-    Phone,
+  /// iPhone and iPod touch.
+  Phone,
 
-    /// iPad.
-    Pad,
+  /// iPad.
+  Pad,
 
-    /// tvOS and Apple TV.
-    TV,
-    CarPlay,
+  /// tvOS and Apple TV.
+  TV,
+  CarPlay,
 }
 
 bitflags! {

src/platform/macos.rs

@@ -3,91 +3,91 @@
 use std::os::raw::c_void;
 
 use crate::{
-    dpi::LogicalSize,
-    event_loop::{EventLoop, EventLoopWindowTarget},
-    monitor::MonitorHandle,
-    platform_impl::get_aux_state_mut,
-    window::{Window, WindowBuilder},
+  dpi::LogicalSize,
+  event_loop::{EventLoop, EventLoopWindowTarget},
+  monitor::MonitorHandle,
+  platform_impl::get_aux_state_mut,
+  window::{Window, WindowBuilder},
 };
 
 /// Additional methods on `Window` that are specific to MacOS.
 pub trait WindowExtMacOS {
-    /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
-    ///
-    /// The pointer will become invalid when the `Window` is destroyed.
-    fn ns_window(&self) -> *mut c_void;
+  /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
+  ///
+  /// The pointer will become invalid when the `Window` is destroyed.
+  fn ns_window(&self) -> *mut c_void;
 
-    /// Returns a pointer to the cocoa `NSView` that is used by this window.
-    ///
-    /// The pointer will become invalid when the `Window` is destroyed.
-    fn ns_view(&self) -> *mut c_void;
+  /// Returns a pointer to the cocoa `NSView` that is used by this window.
+  ///
+  /// The pointer will become invalid when the `Window` is destroyed.
+  fn ns_view(&self) -> *mut c_void;
 
-    /// Returns whether or not the window is in simple fullscreen mode.
-    fn simple_fullscreen(&self) -> bool;
+  /// Returns whether or not the window is in simple fullscreen mode.
+  fn 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;
+  /// 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;
 
-    /// Returns whether or not the window has shadow.
-    fn has_shadow(&self) -> bool;
+  /// Returns whether or not the window has shadow.
+  fn has_shadow(&self) -> bool;
 
-    /// Sets whether or not the window has shadow.
-    fn set_has_shadow(&self, has_shadow: bool);
+  /// Sets whether or not the window has shadow.
+  fn set_has_shadow(&self, has_shadow: bool);
 }
 
 impl WindowExtMacOS for Window {
-    #[inline]
-    fn ns_window(&self) -> *mut c_void {
-        self.window.ns_window()
-    }
+  #[inline]
+  fn ns_window(&self) -> *mut c_void {
+    self.window.ns_window()
+  }
 
-    #[inline]
-    fn ns_view(&self) -> *mut c_void {
-        self.window.ns_view()
-    }
+  #[inline]
+  fn ns_view(&self) -> *mut c_void {
+    self.window.ns_view()
+  }
 
-    #[inline]
-    fn simple_fullscreen(&self) -> bool {
-        self.window.simple_fullscreen()
-    }
+  #[inline]
+  fn simple_fullscreen(&self) -> bool {
+    self.window.simple_fullscreen()
+  }
 
-    #[inline]
-    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        self.window.set_simple_fullscreen(fullscreen)
-    }
+  #[inline]
+  fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
+    self.window.set_simple_fullscreen(fullscreen)
+  }
 
-    #[inline]
-    fn has_shadow(&self) -> bool {
-        self.window.has_shadow()
-    }
+  #[inline]
+  fn has_shadow(&self) -> bool {
+    self.window.has_shadow()
+  }
 
-    #[inline]
-    fn set_has_shadow(&self, has_shadow: bool) {
-        self.window.set_has_shadow(has_shadow)
-    }
+  #[inline]
+  fn set_has_shadow(&self, has_shadow: bool) {
+    self.window.set_has_shadow(has_shadow)
+  }
 }
 
 /// Corresponds to `NSApplicationActivationPolicy`.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ActivationPolicy {
-    /// Corresponds to `NSApplicationActivationPolicyRegular`.
-    Regular,
-    /// Corresponds to `NSApplicationActivationPolicyAccessory`.
-    Accessory,
-    /// Corresponds to `NSApplicationActivationPolicyProhibited`.
-    Prohibited,
+  /// Corresponds to `NSApplicationActivationPolicyRegular`.
+  Regular,
+  /// Corresponds to `NSApplicationActivationPolicyAccessory`.
+  Accessory,
+  /// Corresponds to `NSApplicationActivationPolicyProhibited`.
+  Prohibited,
 }
 
 impl Default for ActivationPolicy {
-    fn default() -> Self {
-        ActivationPolicy::Regular
-    }
+  fn default() -> Self {
+    ActivationPolicy::Regular
+  }
 }
 
 /// Additional methods on `WindowBuilder` that are specific to MacOS.
@@ -101,154 +101,153 @@ impl Default for ActivationPolicy {
 ///  - `with_titlebar_buttons_hidden`
 ///  - `with_fullsize_content_view`
 pub trait WindowBuilderExtMacOS {
-    /// Enables click-and-drag behavior for the entire window, not just the titlebar.
-    fn with_movable_by_window_background(self, movable_by_window_background: bool)
-        -> WindowBuilder;
-    /// Makes the titlebar transparent and allows the content to appear behind it.
-    fn with_titlebar_transparent(self, titlebar_transparent: bool) -> WindowBuilder;
-    /// Hides the window title.
-    fn with_title_hidden(self, title_hidden: bool) -> WindowBuilder;
-    /// Hides the window titlebar.
-    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> WindowBuilder;
-    /// Hides the window titlebar buttons.
-    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> WindowBuilder;
-    /// Makes the window content appear behind the titlebar.
-    fn with_fullsize_content_view(self, fullsize_content_view: bool) -> WindowBuilder;
-    /// Build window with `resizeIncrements` property. Values must not be 0.
-    fn with_resize_increments(self, increments: LogicalSize<f64>) -> WindowBuilder;
-    fn with_disallow_hidpi(self, disallow_hidpi: bool) -> WindowBuilder;
-    fn with_has_shadow(self, has_shadow: bool) -> WindowBuilder;
+  /// Enables click-and-drag behavior for the entire window, not just the titlebar.
+  fn with_movable_by_window_background(self, movable_by_window_background: bool) -> WindowBuilder;
+  /// Makes the titlebar transparent and allows the content to appear behind it.
+  fn with_titlebar_transparent(self, titlebar_transparent: bool) -> WindowBuilder;
+  /// Hides the window title.
+  fn with_title_hidden(self, title_hidden: bool) -> WindowBuilder;
+  /// Hides the window titlebar.
+  fn with_titlebar_hidden(self, titlebar_hidden: bool) -> WindowBuilder;
+  /// Hides the window titlebar buttons.
+  fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> WindowBuilder;
+  /// Makes the window content appear behind the titlebar.
+  fn with_fullsize_content_view(self, fullsize_content_view: bool) -> WindowBuilder;
+  /// Build window with `resizeIncrements` property. Values must not be 0.
+  fn with_resize_increments(self, increments: LogicalSize<f64>) -> WindowBuilder;
+  fn with_disallow_hidpi(self, disallow_hidpi: bool) -> WindowBuilder;
+  fn with_has_shadow(self, has_shadow: bool) -> WindowBuilder;
 }
 
 impl WindowBuilderExtMacOS for WindowBuilder {
-    #[inline]
-    fn with_movable_by_window_background(
-        mut self,
-        movable_by_window_background: bool,
-    ) -> WindowBuilder {
-        self.platform_specific.movable_by_window_background = movable_by_window_background;
-        self
-    }
+  #[inline]
+  fn with_movable_by_window_background(
+    mut self,
+    movable_by_window_background: bool,
+  ) -> WindowBuilder {
+    self.platform_specific.movable_by_window_background = movable_by_window_background;
+    self
+  }
 
-    #[inline]
-    fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> WindowBuilder {
-        self.platform_specific.titlebar_transparent = titlebar_transparent;
-        self
-    }
+  #[inline]
+  fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> WindowBuilder {
+    self.platform_specific.titlebar_transparent = titlebar_transparent;
+    self
+  }
 
-    #[inline]
-    fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> WindowBuilder {
-        self.platform_specific.titlebar_hidden = titlebar_hidden;
-        self
-    }
+  #[inline]
+  fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> WindowBuilder {
+    self.platform_specific.titlebar_hidden = titlebar_hidden;
+    self
+  }
 
-    #[inline]
-    fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> WindowBuilder {
-        self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
-        self
-    }
+  #[inline]
+  fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> WindowBuilder {
+    self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
+    self
+  }
 
-    #[inline]
-    fn with_title_hidden(mut self, title_hidden: bool) -> WindowBuilder {
-        self.platform_specific.title_hidden = title_hidden;
-        self
-    }
+  #[inline]
+  fn with_title_hidden(mut self, title_hidden: bool) -> WindowBuilder {
+    self.platform_specific.title_hidden = title_hidden;
+    self
+  }
 
-    #[inline]
-    fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> WindowBuilder {
-        self.platform_specific.fullsize_content_view = fullsize_content_view;
-        self
-    }
+  #[inline]
+  fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> WindowBuilder {
+    self.platform_specific.fullsize_content_view = fullsize_content_view;
+    self
+  }
 
-    #[inline]
-    fn with_resize_increments(mut self, increments: LogicalSize<f64>) -> WindowBuilder {
-        self.platform_specific.resize_increments = Some(increments.into());
-        self
-    }
+  #[inline]
+  fn with_resize_increments(mut self, increments: LogicalSize<f64>) -> WindowBuilder {
+    self.platform_specific.resize_increments = Some(increments.into());
+    self
+  }
 
-    #[inline]
-    fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> WindowBuilder {
-        self.platform_specific.disallow_hidpi = disallow_hidpi;
-        self
-    }
+  #[inline]
+  fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> WindowBuilder {
+    self.platform_specific.disallow_hidpi = disallow_hidpi;
+    self
+  }
 
-    #[inline]
-    fn with_has_shadow(mut self, has_shadow: bool) -> WindowBuilder {
-        self.platform_specific.has_shadow = has_shadow;
-        self
-    }
+  #[inline]
+  fn with_has_shadow(mut self, has_shadow: bool) -> WindowBuilder {
+    self.platform_specific.has_shadow = has_shadow;
+    self
+  }
 }
 
 pub trait EventLoopExtMacOS {
-    /// Sets the activation policy for the application. It is set to
-    /// `NSApplicationActivationPolicyRegular` by default.
-    ///
-    /// This function only takes effect if it's called before calling [`run`](crate::event_loop::EventLoop::run) or
-    /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
-    fn set_activation_policy(&mut self, activation_policy: ActivationPolicy);
+  /// Sets the activation policy for the application. It is set to
+  /// `NSApplicationActivationPolicyRegular` by default.
+  ///
+  /// This function only takes effect if it's called before calling [`run`](crate::event_loop::EventLoop::run) or
+  /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
+  fn set_activation_policy(&mut self, activation_policy: ActivationPolicy);
 
-    /// Used to prevent a default menubar menu from getting created
-    ///
-    /// The default menu creation is enabled by default.
-    ///
-    /// This function only takes effect if it's called before calling
-    /// [`run`](crate::event_loop::EventLoop::run) or
-    /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
-    fn enable_default_menu_creation(&mut self, enable: bool);
+  /// Used to prevent a default menubar menu from getting created
+  ///
+  /// The default menu creation is enabled by default.
+  ///
+  /// This function only takes effect if it's called before calling
+  /// [`run`](crate::event_loop::EventLoop::run) or
+  /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
+  fn enable_default_menu_creation(&mut self, enable: bool);
 }
 impl<T> EventLoopExtMacOS for EventLoop<T> {
-    #[inline]
-    fn set_activation_policy(&mut self, activation_policy: ActivationPolicy) {
-        unsafe {
-            get_aux_state_mut(&**self.event_loop.delegate).activation_policy = activation_policy;
-        }
+  #[inline]
+  fn set_activation_policy(&mut self, activation_policy: ActivationPolicy) {
+    unsafe {
+      get_aux_state_mut(&**self.event_loop.delegate).activation_policy = activation_policy;
     }
+  }
 
-    #[inline]
-    fn enable_default_menu_creation(&mut self, enable: bool) {
-        unsafe {
-            get_aux_state_mut(&**self.event_loop.delegate).create_default_menu = enable;
-        }
+  #[inline]
+  fn enable_default_menu_creation(&mut self, enable: bool) {
+    unsafe {
+      get_aux_state_mut(&**self.event_loop.delegate).create_default_menu = enable;
     }
+  }
 }
 
 /// Additional methods on `MonitorHandle` that are specific to MacOS.
 pub trait MonitorHandleExtMacOS {
-    /// Returns the identifier of the monitor for Cocoa.
-    fn native_id(&self) -> u32;
-    /// Returns a pointer to the NSScreen representing this monitor.
-    fn ns_screen(&self) -> Option<*mut c_void>;
+  /// Returns the identifier of the monitor for Cocoa.
+  fn native_id(&self) -> u32;
+  /// Returns a pointer to the NSScreen representing this monitor.
+  fn ns_screen(&self) -> Option<*mut c_void>;
 }
 
 impl MonitorHandleExtMacOS for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> u32 {
-        self.inner.native_identifier()
-    }
+  #[inline]
+  fn native_id(&self) -> u32 {
+    self.inner.native_identifier()
+  }
 
-    fn ns_screen(&self) -> Option<*mut c_void> {
-        self.inner.ns_screen().map(|s| s as *mut c_void)
-    }
+  fn ns_screen(&self) -> Option<*mut c_void> {
+    self.inner.ns_screen().map(|s| s as *mut c_void)
+  }
 }
 
 /// Additional methods on `EventLoopWindowTarget` that are specific to macOS.
 pub trait EventLoopWindowTargetExtMacOS {
-    /// Hide the entire application. In most applications this is typically triggered with Command-H.
-    fn hide_application(&self);
-    /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
-    fn hide_other_applications(&self);
+  /// Hide the entire application. In most applications this is typically triggered with Command-H.
+  fn hide_application(&self);
+  /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
+  fn hide_other_applications(&self);
 }
 
 impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
-    fn hide_application(&self) {
-        let cls = objc::runtime::Class::get("NSApplication").unwrap();
-        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
-        unsafe { msg_send![app, hide: 0] }
-    }
+  fn hide_application(&self) {
+    let cls = objc::runtime::Class::get("NSApplication").unwrap();
+    let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
+    unsafe { msg_send![app, hide: 0] }
+  }
 
-    fn hide_other_applications(&self) {
-        let cls = objc::runtime::Class::get("NSApplication").unwrap();
-        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
-        unsafe { msg_send![app, hideOtherApplications: 0] }
-    }
+  fn hide_other_applications(&self) {
+    let cls = objc::runtime::Class::get("NSApplication").unwrap();
+    let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
+    unsafe { msg_send![app, hideOtherApplications: 0] }
+  }
 }

src/platform/mod.rs

@@ -7,7 +7,6 @@
 //!  - `macos`
 //!  - `unix`
 //!  - `windows`
-//!  - `web`
 //!
 //! And the following platform-specific module:
 //!

src/platform/run_return.rs

@@ -1,49 +1,41 @@
 #![cfg(any(target_os = "windows", target_os = "macos", target_os = "android",))]
 
 use crate::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+  event::Event,
+  event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
 };
 
 /// Additional methods on `EventLoop` to return control flow to the caller.
 pub trait EventLoopExtRunReturn {
-    /// A type provided by the user that can be passed through `Event::UserEvent`.
-    type UserEvent;
+  /// A type provided by the user that can be passed through `Event::UserEvent`.
+  type UserEvent;
 
-    /// Initializes the `winit` event loop.
-    ///
-    /// Unlike `run`, this function accepts non-`'static` (i.e. non-`move`) closures and returns
-    /// control flow to the caller when `control_flow` is set to `ControlFlow::Exit`.
-    ///
-    /// # Caveats
-    /// Despite its appearance at first glance, this is *not* a perfect replacement for
-    /// `poll_events`. For example, this function will not return on Windows or macOS while a
-    /// window is getting resized, resulting in all application logic outside of the
-    /// `event_handler` closure not running until the resize operation ends. Other OS operations
-    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
-    /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
-    ///
-    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
-    fn run_return<F>(&mut self, event_handler: F)
-    where
-        F: FnMut(
-            Event<'_, Self::UserEvent>,
-            &EventLoopWindowTarget<Self::UserEvent>,
-            &mut ControlFlow,
-        );
+  /// Initializes the `winit` event loop.
+  ///
+  /// Unlike `run`, this function accepts non-`'static` (i.e. non-`move`) closures and returns
+  /// control flow to the caller when `control_flow` is set to `ControlFlow::Exit`.
+  ///
+  /// # Caveats
+  /// Despite its appearance at first glance, this is *not* a perfect replacement for
+  /// `poll_events`. For example, this function will not return on Windows or macOS while a
+  /// window is getting resized, resulting in all application logic outside of the
+  /// `event_handler` closure not running until the resize operation ends. Other OS operations
+  /// may also result in such freezes. This behavior is caused by fundamental limitations in the
+  /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
+  ///
+  /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
+  fn run_return<F>(&mut self, event_handler: F)
+  where
+    F: FnMut(Event<'_, Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
 }
 
 impl<T> EventLoopExtRunReturn for EventLoop<T> {
-    type UserEvent = T;
+  type UserEvent = T;
 
-    fn run_return<F>(&mut self, event_handler: F)
-    where
-        F: FnMut(
-            Event<'_, Self::UserEvent>,
-            &EventLoopWindowTarget<Self::UserEvent>,
-            &mut ControlFlow,
-        ),
-    {
-        self.event_loop.run_return(event_handler)
-    }
+  fn run_return<F>(&mut self, event_handler: F)
+  where
+    F: FnMut(Event<'_, Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow),
+  {
+    self.event_loop.run_return(event_handler)
+  }
 }

src/platform/unix.rs

@@ -1,9 +1,9 @@
 #![cfg(any(
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
+  target_os = "linux",
+  target_os = "dragonfly",
+  target_os = "freebsd",
+  target_os = "netbsd",
+  target_os = "openbsd"
 ))]
 
 use crate::window::Window;
@@ -12,21 +12,21 @@ pub use crate::platform_impl::hit_test;
 
 /// Additional methods on `Window` that are specific to Unix.
 pub trait WindowExtUnix {
-    /// Returns the `ApplicatonWindow` from gtk crate that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    fn gtk_window(&self) -> &gtk::ApplicationWindow;
+  /// Returns the `ApplicatonWindow` from gtk crate that is used by this window.
+  ///
+  /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+  fn gtk_window(&self) -> &gtk::ApplicationWindow;
 
-    /// Not to display window icon in the task bar.
-    fn skip_taskbar(&self);
+  /// Not to display window icon in the task bar.
+  fn skip_taskbar(&self);
 }
 
 impl WindowExtUnix for Window {
-    fn gtk_window(&self) -> &gtk::ApplicationWindow {
-        &self.window.window
-    }
+  fn gtk_window(&self) -> &gtk::ApplicationWindow {
+    &self.window.window
+  }
 
-    fn skip_taskbar(&self) {
-        self.window.skip_taskbar()
-    }
+  fn skip_taskbar(&self) {
+    self.window.skip_taskbar()
+  }
 }

src/platform/windows.rs

@@ -8,289 +8,285 @@ use winapi::shared::minwindef::WORD;
 use winapi::shared::windef::{HMENU, HWND};
 
 use crate::{
-    dpi::PhysicalSize,
-    event::DeviceId,
-    event_loop::EventLoop,
-    monitor::MonitorHandle,
-    platform_impl::{EventLoop as WindowsEventLoop, Parent, WinIcon},
-    window::{BadIcon, Icon, Theme, Window, WindowBuilder},
+  dpi::PhysicalSize,
+  event::DeviceId,
+  event_loop::EventLoop,
+  monitor::MonitorHandle,
+  platform_impl::{EventLoop as WindowsEventLoop, Parent, WinIcon},
+  window::{BadIcon, Icon, Theme, Window, WindowBuilder},
 };
 
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopExtWindows {
-    /// Creates an event loop off of the main thread.
-    ///
-    /// # `Window` caveats
-    ///
-    /// Note that any `Window` created on the new thread will be destroyed when the thread
-    /// terminates. Attempting to use a `Window` after its parent thread terminates has
-    /// unspecified, although explicitly not undefined, behavior.
-    fn new_any_thread() -> Self
-    where
-        Self: Sized;
+  /// Creates an event loop off of the main thread.
+  ///
+  /// # `Window` caveats
+  ///
+  /// Note that any `Window` created on the new thread will be destroyed when the thread
+  /// terminates. Attempting to use a `Window` after its parent thread terminates has
+  /// unspecified, although explicitly not undefined, behavior.
+  fn new_any_thread() -> Self
+  where
+    Self: Sized;
 
-    /// By default, winit on Windows will attempt to enable process-wide DPI awareness. If that's
-    /// undesirable, you can create an `EventLoop` using this function instead.
-    fn new_dpi_unaware() -> Self
-    where
-        Self: Sized;
+  /// By default, winit on Windows will attempt to enable process-wide DPI awareness. If that's
+  /// undesirable, you can create an `EventLoop` using this function instead.
+  fn new_dpi_unaware() -> Self
+  where
+    Self: Sized;
 
-    /// Creates a DPI-unaware event loop off of the main thread.
-    ///
-    /// The `Window` caveats in [`new_any_thread`](EventLoopExtWindows::new_any_thread) also apply here.
-    fn new_dpi_unaware_any_thread() -> Self
-    where
-        Self: Sized;
+  /// Creates a DPI-unaware event loop off of the main thread.
+  ///
+  /// The `Window` caveats in [`new_any_thread`](EventLoopExtWindows::new_any_thread) also apply here.
+  fn new_dpi_unaware_any_thread() -> Self
+  where
+    Self: Sized;
 }
 
 impl<T> EventLoopExtWindows for EventLoop<T> {
-    #[inline]
-    fn new_any_thread() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_any_thread(),
-            _marker: ::std::marker::PhantomData,
-        }
+  #[inline]
+  fn new_any_thread() -> Self {
+    EventLoop {
+      event_loop: WindowsEventLoop::new_any_thread(),
+      _marker: ::std::marker::PhantomData,
     }
+  }
 
-    #[inline]
-    fn new_dpi_unaware() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_dpi_unaware(),
-            _marker: ::std::marker::PhantomData,
-        }
+  #[inline]
+  fn new_dpi_unaware() -> Self {
+    EventLoop {
+      event_loop: WindowsEventLoop::new_dpi_unaware(),
+      _marker: ::std::marker::PhantomData,
     }
+  }
 
-    #[inline]
-    fn new_dpi_unaware_any_thread() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_dpi_unaware_any_thread(),
-            _marker: ::std::marker::PhantomData,
-        }
+  #[inline]
+  fn new_dpi_unaware_any_thread() -> Self {
+    EventLoop {
+      event_loop: WindowsEventLoop::new_dpi_unaware_any_thread(),
+      _marker: ::std::marker::PhantomData,
     }
+  }
 }
 
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
-    /// Returns the HINSTANCE of the window
-    fn hinstance(&self) -> *mut libc::c_void;
-    /// Returns the native handle that is used by this window.
-    ///
-    /// The pointer will become invalid when the native window was destroyed.
-    fn hwnd(&self) -> *mut libc::c_void;
+  /// Returns the HINSTANCE of the window
+  fn hinstance(&self) -> *mut libc::c_void;
+  /// Returns the native handle that is used by this window.
+  ///
+  /// The pointer will become invalid when the native window was destroyed.
+  fn hwnd(&self) -> *mut libc::c_void;
 
-    /// Enables or disables mouse and keyboard input to the specified window.
-    ///
-    /// A window must be enabled before it can be activated.
-    /// If an application has create a modal dialog box by disabling its owner window
-    /// (as described in [`WindowBuilderExtWindows::with_owner_window`]), the application must enable
-    /// the owner window before destroying the dialog box.
-    /// Otherwise, another window will receive the keyboard focus and be activated.
-    ///
-    /// If a child window is disabled, it is ignored when the system tries to determine which
-    /// window should receive mouse messages.
-    ///
-    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
-    /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
-    fn set_enable(&self, enabled: bool);
+  /// Enables or disables mouse and keyboard input to the specified window.
+  ///
+  /// A window must be enabled before it can be activated.
+  /// If an application has create a modal dialog box by disabling its owner window
+  /// (as described in [`WindowBuilderExtWindows::with_owner_window`]), the application must enable
+  /// the owner window before destroying the dialog box.
+  /// Otherwise, another window will receive the keyboard focus and be activated.
+  ///
+  /// If a child window is disabled, it is ignored when the system tries to determine which
+  /// window should receive mouse messages.
+  ///
+  /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
+  /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
+  fn set_enable(&self, enabled: bool);
 
-    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
-    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
+  /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+  fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
 
-    /// Returns the current window theme.
-    fn theme(&self) -> Theme;
+  /// Returns the current window theme.
+  fn theme(&self) -> Theme;
 }
 
 impl WindowExtWindows for Window {
-    #[inline]
-    fn hinstance(&self) -> *mut libc::c_void {
-        self.window.hinstance() as *mut _
-    }
+  #[inline]
+  fn hinstance(&self) -> *mut libc::c_void {
+    self.window.hinstance() as *mut _
+  }
 
-    #[inline]
-    fn hwnd(&self) -> *mut libc::c_void {
-        self.window.hwnd() as *mut _
-    }
+  #[inline]
+  fn hwnd(&self) -> *mut libc::c_void {
+    self.window.hwnd() as *mut _
+  }
 
-    #[inline]
-    fn set_enable(&self, enabled: bool) {
-        unsafe {
-            winapi::um::winuser::EnableWindow(self.hwnd() as _, enabled as _);
-        }
+  #[inline]
+  fn set_enable(&self, enabled: bool) {
+    unsafe {
+      winapi::um::winuser::EnableWindow(self.hwnd() as _, enabled as _);
     }
+  }
 
-    #[inline]
-    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
-        self.window.set_taskbar_icon(taskbar_icon)
-    }
+  #[inline]
+  fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
+    self.window.set_taskbar_icon(taskbar_icon)
+  }
 
-    #[inline]
-    fn theme(&self) -> Theme {
-        self.window.theme()
-    }
+  #[inline]
+  fn theme(&self) -> Theme {
+    self.window.theme()
+  }
 }
 
 /// Additional methods on `WindowBuilder` that are specific to Windows.
 pub trait WindowBuilderExtWindows {
-    /// Sets a parent to the window to be created.
-    ///
-    /// A child window has the WS_CHILD style and is confined to the client area of its parent window.
-    ///
-    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
-    fn with_parent_window(self, parent: HWND) -> WindowBuilder;
+  /// Sets a parent to the window to be created.
+  ///
+  /// A child window has the WS_CHILD style and is confined to the client area of its parent window.
+  ///
+  /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
+  fn with_parent_window(self, parent: HWND) -> WindowBuilder;
 
-    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
-    /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
-    /// on the owner window to create a modal dialog box.
-    ///
-    /// From MSDN:
-    /// - An owned window is always above its owner in the z-order.
-    /// - The system automatically destroys an owned window when its owner is destroyed.
-    /// - An owned window is hidden when its owner is minimized.
-    ///
-    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
-    fn with_owner_window(self, parent: HWND) -> WindowBuilder;
+  /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
+  /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
+  /// on the owner window to create a modal dialog box.
+  ///
+  /// From MSDN:
+  /// - An owned window is always above its owner in the z-order.
+  /// - The system automatically destroys an owned window when its owner is destroyed.
+  /// - An owned window is hidden when its owner is minimized.
+  ///
+  /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
+  fn with_owner_window(self, parent: HWND) -> WindowBuilder;
 
-    /// Sets a menu on the window to be created.
-    ///
-    /// Parent and menu are mutually exclusive; a child window cannot have a menu!
-    ///
-    /// The menu must have been manually created beforehand with [`winapi::um::winuser::CreateMenu`] or similar.
-    ///
-    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
-    /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
-    fn with_menu(self, menu: HMENU) -> WindowBuilder;
+  /// Sets a menu on the window to be created.
+  ///
+  /// Parent and menu are mutually exclusive; a child window cannot have a menu!
+  ///
+  /// The menu must have been manually created beforehand with [`winapi::um::winuser::CreateMenu`] or similar.
+  ///
+  /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
+  /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
+  fn with_menu(self, menu: HMENU) -> WindowBuilder;
 
-    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
-    fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> WindowBuilder;
+  /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+  fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> WindowBuilder;
 
-    /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
-    fn with_no_redirection_bitmap(self, flag: bool) -> WindowBuilder;
+  /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
+  fn with_no_redirection_bitmap(self, flag: bool) -> WindowBuilder;
 
-    /// Enables or disables drag and drop support (enabled by default). Will interfere with other crates
-    /// that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED` instead of
-    /// `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still attempt to initialize
-    /// COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future.
-    /// If you need COM API with `COINIT_MULTITHREADED` you must initialize it before calling any winit functions.
-    /// See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
-    fn with_drag_and_drop(self, flag: bool) -> WindowBuilder;
+  /// Enables or disables drag and drop support (enabled by default). Will interfere with other crates
+  /// that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED` instead of
+  /// `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still attempt to initialize
+  /// COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future.
+  /// If you need COM API with `COINIT_MULTITHREADED` you must initialize it before calling any winit functions.
+  /// See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
+  fn with_drag_and_drop(self, flag: bool) -> WindowBuilder;
 
-    /// Forces a theme or uses the system settings if `None` was provided.
-    fn with_theme(self, theme: Option<Theme>) -> WindowBuilder;
+  /// Forces a theme or uses the system settings if `None` was provided.
+  fn with_theme(self, theme: Option<Theme>) -> WindowBuilder;
 }
 
 impl WindowBuilderExtWindows for WindowBuilder {
-    #[inline]
-    fn with_parent_window(mut self, parent: HWND) -> WindowBuilder {
-        self.platform_specific.parent = Parent::ChildOf(parent);
-        self
-    }
+  #[inline]
+  fn with_parent_window(mut self, parent: HWND) -> WindowBuilder {
+    self.platform_specific.parent = Parent::ChildOf(parent);
+    self
+  }
 
-    #[inline]
-    fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
-        self.platform_specific.parent = Parent::OwnedBy(parent);
-        self
-    }
+  #[inline]
+  fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
+    self.platform_specific.parent = Parent::OwnedBy(parent);
+    self
+  }
 
-    #[inline]
-    fn with_menu(mut self, menu: HMENU) -> WindowBuilder {
-        self.platform_specific.menu = Some(menu);
-        self
-    }
+  #[inline]
+  fn with_menu(mut self, menu: HMENU) -> WindowBuilder {
+    self.platform_specific.menu = Some(menu);
+    self
+  }
 
-    #[inline]
-    fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> WindowBuilder {
-        self.platform_specific.taskbar_icon = taskbar_icon;
-        self
-    }
+  #[inline]
+  fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> WindowBuilder {
+    self.platform_specific.taskbar_icon = taskbar_icon;
+    self
+  }
 
-    #[inline]
-    fn with_no_redirection_bitmap(mut self, flag: bool) -> WindowBuilder {
-        self.platform_specific.no_redirection_bitmap = flag;
-        self
-    }
+  #[inline]
+  fn with_no_redirection_bitmap(mut self, flag: bool) -> WindowBuilder {
+    self.platform_specific.no_redirection_bitmap = flag;
+    self
+  }
 
-    #[inline]
-    fn with_drag_and_drop(mut self, flag: bool) -> WindowBuilder {
-        self.platform_specific.drag_and_drop = flag;
-        self
-    }
+  #[inline]
+  fn with_drag_and_drop(mut self, flag: bool) -> WindowBuilder {
+    self.platform_specific.drag_and_drop = flag;
+    self
+  }
 
-    #[inline]
-    fn with_theme(mut self, theme: Option<Theme>) -> WindowBuilder {
-        self.platform_specific.preferred_theme = theme;
-        self
-    }
+  #[inline]
+  fn with_theme(mut self, theme: Option<Theme>) -> WindowBuilder {
+    self.platform_specific.preferred_theme = theme;
+    self
+  }
 }
 
 /// Additional methods on `MonitorHandle` that are specific to Windows.
 pub trait MonitorHandleExtWindows {
-    /// Returns the name of the monitor adapter specific to the Win32 API.
-    fn native_id(&self) -> String;
+  /// Returns the name of the monitor adapter specific to the Win32 API.
+  fn native_id(&self) -> String;
 
-    /// Returns the handle of the monitor - `HMONITOR`.
-    fn hmonitor(&self) -> *mut c_void;
+  /// Returns the handle of the monitor - `HMONITOR`.
+  fn hmonitor(&self) -> *mut c_void;
 }
 
 impl MonitorHandleExtWindows for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> String {
-        self.inner.native_identifier()
-    }
+  #[inline]
+  fn native_id(&self) -> String {
+    self.inner.native_identifier()
+  }
 
-    #[inline]
-    fn hmonitor(&self) -> *mut c_void {
-        self.inner.hmonitor() as *mut _
-    }
+  #[inline]
+  fn hmonitor(&self) -> *mut c_void {
+    self.inner.hmonitor() as *mut _
+  }
 }
 
 /// Additional methods on `DeviceId` that are specific to Windows.
 pub trait DeviceIdExtWindows {
-    /// Returns an identifier that persistently refers to this specific device.
-    ///
-    /// Will return `None` if the device is no longer available.
-    fn persistent_identifier(&self) -> Option<String>;
+  /// Returns an identifier that persistently refers to this specific device.
+  ///
+  /// Will return `None` if the device is no longer available.
+  fn persistent_identifier(&self) -> Option<String>;
 }
 
 impl DeviceIdExtWindows for DeviceId {
-    #[inline]
-    fn persistent_identifier(&self) -> Option<String> {
-        self.0.persistent_identifier()
-    }
+  #[inline]
+  fn persistent_identifier(&self) -> Option<String> {
+    self.0.persistent_identifier()
+  }
 }
 
 /// Additional methods on `Icon` that are specific to Windows.
 pub trait IconExtWindows: Sized {
-    /// Create an icon from a file path.
-    ///
-    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
-    /// icon size from the file.
-    ///
-    /// In cases where the specified size does not exist in the file, Windows may perform scaling
-    /// to get an icon of the desired size.
-    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
-        -> Result<Self, BadIcon>;
+  /// Create an icon from a file path.
+  ///
+  /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+  /// icon size from the file.
+  ///
+  /// In cases where the specified size does not exist in the file, Windows may perform scaling
+  /// to get an icon of the desired size.
+  fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
 
-    /// Create an icon from a resource embedded in this executable or library.
-    ///
-    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
-    /// icon size from the file.
-    ///
-    /// In cases where the specified size does not exist in the file, Windows may perform scaling
-    /// to get an icon of the desired size.
-    fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+  /// Create an icon from a resource embedded in this executable or library.
+  ///
+  /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+  /// icon size from the file.
+  ///
+  /// In cases where the specified size does not exist in the file, Windows may perform scaling
+  /// to get an icon of the desired size.
+  fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
 }
 
 impl IconExtWindows for Icon {
-    fn from_path<P: AsRef<Path>>(
-        path: P,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        let win_icon = WinIcon::from_path(path, size)?;
-        Ok(Icon { inner: win_icon })
-    }
+  fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+    let win_icon = WinIcon::from_path(path, size)?;
+    Ok(Icon { inner: win_icon })
+  }
 
-    fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
-        let win_icon = WinIcon::from_resource(ordinal, size)?;
-        Ok(Icon { inner: win_icon })
-    }
+  fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+    let win_icon = WinIcon::from_resource(ordinal, size)?;
+    Ok(Icon { inner: win_icon })
+  }
 }

src/platform_impl/ios/event_loop.rs

@@ -1,344 +1,341 @@
 use std::{
-    collections::VecDeque,
-    ffi::c_void,
-    fmt::{self, Debug},
-    marker::PhantomData,
-    mem, ptr,
-    sync::mpsc::{self, Receiver, Sender},
+  collections::VecDeque,
+  ffi::c_void,
+  fmt::{self, Debug},
+  marker::PhantomData,
+  mem, ptr,
+  sync::mpsc::{self, Receiver, Sender},
 };
 
 use crate::{
-    dpi::LogicalSize,
-    event::Event,
-    event_loop::{
-        ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootEventLoopWindowTarget,
-    },
-    monitor::MonitorHandle as RootMonitorHandle,
-    platform::ios::Idiom,
+  dpi::LogicalSize,
+  event::Event,
+  event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootEventLoopWindowTarget},
+  monitor::MonitorHandle as RootMonitorHandle,
+  platform::ios::Idiom,
 };
 
 use crate::platform_impl::platform::{
-    app_state,
-    ffi::{
-        id, kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes,
-        kCFRunLoopDefaultMode, kCFRunLoopEntry, kCFRunLoopExit, nil, CFIndex, CFRelease,
-        CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
-        CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext,
-        CFRunLoopSourceCreate, CFRunLoopSourceInvalidate, CFRunLoopSourceRef,
-        CFRunLoopSourceSignal, CFRunLoopWakeUp, NSStringRust, UIApplicationMain,
-        UIUserInterfaceIdiom,
-    },
-    monitor, view, MonitorHandle,
+  app_state,
+  ffi::{
+    id, kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes,
+    kCFRunLoopDefaultMode, kCFRunLoopEntry, kCFRunLoopExit, nil, CFIndex, CFRelease,
+    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
+    CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
+    NSStringRust, UIApplicationMain, UIUserInterfaceIdiom,
+  },
+  monitor, view, MonitorHandle,
 };
 
 #[derive(Debug)]
 pub enum EventWrapper {
-    StaticEvent(Event<'static, Never>),
-    EventProxy(EventProxy),
+  StaticEvent(Event<'static, Never>),
+  EventProxy(EventProxy),
 }
 
 #[derive(Debug, PartialEq)]
 pub enum EventProxy {
-    DpiChangedProxy {
-        window_id: id,
-        suggested_size: LogicalSize<f64>,
-        scale_factor: f64,
-    },
+  DpiChangedProxy {
+    window_id: id,
+    suggested_size: LogicalSize<f64>,
+    scale_factor: f64,
+  },
 }
 
 pub struct EventLoopWindowTarget<T: 'static> {
-    receiver: Receiver<T>,
-    sender_to_clone: Sender<T>,
+  receiver: Receiver<T>,
+  sender_to_clone: Sender<T>,
 }
 
 impl<T: 'static> EventLoopWindowTarget<T> {
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        // guaranteed to be on main thread
-        unsafe { monitor::uiscreens() }
-    }
+  pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+    // guaranteed to be on main thread
+    unsafe { monitor::uiscreens() }
+  }
 
-    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
-        // guaranteed to be on main thread
-        let monitor = unsafe { monitor::main_uiscreen() };
+  pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    // guaranteed to be on main thread
+    let monitor = unsafe { monitor::main_uiscreen() };
 
-        Some(RootMonitorHandle { inner: monitor })
-    }
+    Some(RootMonitorHandle { inner: monitor })
+  }
 }
 
 pub struct EventLoop<T: 'static> {
-    window_target: RootEventLoopWindowTarget<T>,
+  window_target: RootEventLoopWindowTarget<T>,
 }
 
 impl<T: 'static> EventLoop<T> {
-    pub fn new() -> EventLoop<T> {
-        static mut SINGLETON_INIT: bool = false;
-        unsafe {
-            assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
-            assert!(
-                !SINGLETON_INIT,
-                "Only one `EventLoop` is supported on iOS. \
+  pub fn new() -> EventLoop<T> {
+    static mut SINGLETON_INIT: bool = false;
+    unsafe {
+      assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
+      assert!(
+        !SINGLETON_INIT,
+        "Only one `EventLoop` is supported on iOS. \
                  `EventLoopProxy` might be helpful"
-            );
-            SINGLETON_INIT = true;
-            view::create_delegate_class();
-        }
-
-        let (sender_to_clone, receiver) = mpsc::channel();
-
-        // this line sets up the main run loop before `UIApplicationMain`
-        setup_control_flow_observers();
-
-        EventLoop {
-            window_target: RootEventLoopWindowTarget {
-                p: EventLoopWindowTarget {
-                    receiver,
-                    sender_to_clone,
-                },
-                _marker: PhantomData,
-            },
-        }
+      );
+      SINGLETON_INIT = true;
+      view::create_delegate_class();
     }
 
-    pub fn run<F>(self, event_handler: F) -> !
-    where
-        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
-    {
-        unsafe {
-            let application: *mut c_void = msg_send![class!(UIApplication), sharedApplication];
-            assert_eq!(
-                application,
-                ptr::null_mut(),
-                "\
+    let (sender_to_clone, receiver) = mpsc::channel();
+
+    // this line sets up the main run loop before `UIApplicationMain`
+    setup_control_flow_observers();
+
+    EventLoop {
+      window_target: RootEventLoopWindowTarget {
+        p: EventLoopWindowTarget {
+          receiver,
+          sender_to_clone,
+        },
+        _marker: PhantomData,
+      },
+    }
+  }
+
+  pub fn run<F>(self, event_handler: F) -> !
+  where
+    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+  {
+    unsafe {
+      let application: *mut c_void = msg_send![class!(UIApplication), sharedApplication];
+      assert_eq!(
+        application,
+        ptr::null_mut(),
+        "\
                  `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
                  Note: `EventLoop::run` calls `UIApplicationMain` on iOS"
-            );
-            app_state::will_launch(Box::new(EventLoopHandler {
-                f: event_handler,
-                event_loop: self.window_target,
-            }));
+      );
+      app_state::will_launch(Box::new(EventLoopHandler {
+        f: event_handler,
+        event_loop: self.window_target,
+      }));
 
-            UIApplicationMain(
-                0,
-                ptr::null(),
-                nil,
-                NSStringRust::alloc(nil).init_str("AppDelegate"),
-            );
-            unreachable!()
-        }
+      UIApplicationMain(
+        0,
+        ptr::null(),
+        nil,
+        NSStringRust::alloc(nil).init_str("AppDelegate"),
+      );
+      unreachable!()
     }
+  }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.window_target.p.sender_to_clone.clone())
-    }
+  pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    EventLoopProxy::new(self.window_target.p.sender_to_clone.clone())
+  }
 
-    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
-        &self.window_target
-    }
+  pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
+    &self.window_target
+  }
 }
 
 // EventLoopExtIOS
 impl<T: 'static> EventLoop<T> {
-    pub fn idiom(&self) -> Idiom {
-        // guaranteed to be on main thread
-        unsafe { self::get_idiom() }
-    }
+  pub fn idiom(&self) -> Idiom {
+    // guaranteed to be on main thread
+    unsafe { self::get_idiom() }
+  }
 }
 
 pub struct EventLoopProxy<T> {
-    sender: Sender<T>,
-    source: CFRunLoopSourceRef,
+  sender: Sender<T>,
+  source: CFRunLoopSourceRef,
 }
 
 unsafe impl<T: Send> Send for EventLoopProxy<T> {}
 
 impl<T> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
-    }
+  fn clone(&self) -> EventLoopProxy<T> {
+    EventLoopProxy::new(self.sender.clone())
+  }
 }
 
 impl<T> Drop for EventLoopProxy<T> {
-    fn drop(&mut self) {
-        unsafe {
-            CFRunLoopSourceInvalidate(self.source);
-            CFRelease(self.source as _);
-        }
+  fn drop(&mut self) {
+    unsafe {
+      CFRunLoopSourceInvalidate(self.source);
+      CFRelease(self.source as _);
     }
+  }
 }
 
 impl<T> EventLoopProxy<T> {
-    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
-        unsafe {
-            // just wake up the eventloop
-            extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
+  fn new(sender: Sender<T>) -> EventLoopProxy<T> {
+    unsafe {
+      // just wake up the eventloop
+      extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
 
-            // adding a Source to the main CFRunLoop lets us wake it up and
-            // process user events through the normal OS EventLoop mechanisms.
-            let rl = CFRunLoopGetMain();
-            // we want all the members of context to be zero/null, except one
-            let mut context: CFRunLoopSourceContext = mem::zeroed();
-            context.perform = Some(event_loop_proxy_handler);
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
-            CFRunLoopWakeUp(rl);
+      // adding a Source to the main CFRunLoop lets us wake it up and
+      // process user events through the normal OS EventLoop mechanisms.
+      let rl = CFRunLoopGetMain();
+      // we want all the members of context to be zero/null, except one
+      let mut context: CFRunLoopSourceContext = mem::zeroed();
+      context.perform = Some(event_loop_proxy_handler);
+      let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
+      CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+      CFRunLoopWakeUp(rl);
 
-            EventLoopProxy { sender, source }
-        }
+      EventLoopProxy { sender, source }
     }
+  }
 
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender
-            .send(event)
-            .map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
-        unsafe {
-            // let the main thread know there's a new event
-            CFRunLoopSourceSignal(self.source);
-            let rl = CFRunLoopGetMain();
-            CFRunLoopWakeUp(rl);
-        }
-        Ok(())
+  pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+    self
+      .sender
+      .send(event)
+      .map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
+    unsafe {
+      // let the main thread know there's a new event
+      CFRunLoopSourceSignal(self.source);
+      let rl = CFRunLoopGetMain();
+      CFRunLoopWakeUp(rl);
     }
+    Ok(())
+  }
 }
 
 fn setup_control_flow_observers() {
-    unsafe {
-        // begin is queued with the highest priority to ensure it is processed before other observers
-        extern "C" fn control_flow_begin_handler(
-            _: CFRunLoopObserverRef,
-            activity: CFRunLoopActivity,
-            _: *mut c_void,
-        ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(),
-                    kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
-                    _ => unreachable!(),
-                }
-            }
+  unsafe {
+    // begin is queued with the highest priority to ensure it is processed before other observers
+    extern "C" fn control_flow_begin_handler(
+      _: CFRunLoopObserverRef,
+      activity: CFRunLoopActivity,
+      _: *mut c_void,
+    ) {
+      unsafe {
+        #[allow(non_upper_case_globals)]
+        match activity {
+          kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(),
+          kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
+          _ => unreachable!(),
         }
-
-        // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
-        // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
-        // priority to be 0, in order to send MainEventsCleared before RedrawRequested. This value was
-        // chosen conservatively to guard against apple using different priorities for their redraw
-        // observers in different OS's or on different devices. If it so happens that it's too
-        // conservative, the main symptom would be non-redraw events coming in after `MainEventsCleared`.
-        //
-        // The value of `0x1e8480` was determined by inspecting stack traces and the associated
-        // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
-        //
-        // Also tested to be `0x1e8480` on iPhone 8, iOS 13 beta 4.
-        extern "C" fn control_flow_main_end_handler(
-            _: CFRunLoopObserverRef,
-            activity: CFRunLoopActivity,
-            _: *mut c_void,
-        ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(),
-                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
-                    _ => unreachable!(),
-                }
-            }
-        }
-
-        // end is queued with the lowest priority to ensure it is processed after other observers
-        extern "C" fn control_flow_end_handler(
-            _: CFRunLoopObserverRef,
-            activity: CFRunLoopActivity,
-            _: *mut c_void,
-        ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(),
-                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
-                    _ => unreachable!(),
-                }
-            }
-        }
-
-        let main_loop = CFRunLoopGetMain();
-
-        let begin_observer = CFRunLoopObserverCreate(
-            ptr::null_mut(),
-            kCFRunLoopEntry | kCFRunLoopAfterWaiting,
-            1, // repeat = true
-            CFIndex::min_value(),
-            control_flow_begin_handler,
-            ptr::null_mut(),
-        );
-        CFRunLoopAddObserver(main_loop, begin_observer, kCFRunLoopDefaultMode);
-
-        let main_end_observer = CFRunLoopObserverCreate(
-            ptr::null_mut(),
-            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
-            1, // repeat = true
-            0, // see comment on `control_flow_main_end_handler`
-            control_flow_main_end_handler,
-            ptr::null_mut(),
-        );
-        CFRunLoopAddObserver(main_loop, main_end_observer, kCFRunLoopDefaultMode);
-
-        let end_observer = CFRunLoopObserverCreate(
-            ptr::null_mut(),
-            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
-            1, // repeat = true
-            CFIndex::max_value(),
-            control_flow_end_handler,
-            ptr::null_mut(),
-        );
-        CFRunLoopAddObserver(main_loop, end_observer, kCFRunLoopDefaultMode);
+      }
     }
+
+    // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
+    // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
+    // priority to be 0, in order to send MainEventsCleared before RedrawRequested. This value was
+    // chosen conservatively to guard against apple using different priorities for their redraw
+    // observers in different OS's or on different devices. If it so happens that it's too
+    // conservative, the main symptom would be non-redraw events coming in after `MainEventsCleared`.
+    //
+    // The value of `0x1e8480` was determined by inspecting stack traces and the associated
+    // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
+    //
+    // Also tested to be `0x1e8480` on iPhone 8, iOS 13 beta 4.
+    extern "C" fn control_flow_main_end_handler(
+      _: CFRunLoopObserverRef,
+      activity: CFRunLoopActivity,
+      _: *mut c_void,
+    ) {
+      unsafe {
+        #[allow(non_upper_case_globals)]
+        match activity {
+          kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(),
+          kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+          _ => unreachable!(),
+        }
+      }
+    }
+
+    // end is queued with the lowest priority to ensure it is processed after other observers
+    extern "C" fn control_flow_end_handler(
+      _: CFRunLoopObserverRef,
+      activity: CFRunLoopActivity,
+      _: *mut c_void,
+    ) {
+      unsafe {
+        #[allow(non_upper_case_globals)]
+        match activity {
+          kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(),
+          kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+          _ => unreachable!(),
+        }
+      }
+    }
+
+    let main_loop = CFRunLoopGetMain();
+
+    let begin_observer = CFRunLoopObserverCreate(
+      ptr::null_mut(),
+      kCFRunLoopEntry | kCFRunLoopAfterWaiting,
+      1, // repeat = true
+      CFIndex::min_value(),
+      control_flow_begin_handler,
+      ptr::null_mut(),
+    );
+    CFRunLoopAddObserver(main_loop, begin_observer, kCFRunLoopDefaultMode);
+
+    let main_end_observer = CFRunLoopObserverCreate(
+      ptr::null_mut(),
+      kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+      1, // repeat = true
+      0, // see comment on `control_flow_main_end_handler`
+      control_flow_main_end_handler,
+      ptr::null_mut(),
+    );
+    CFRunLoopAddObserver(main_loop, main_end_observer, kCFRunLoopDefaultMode);
+
+    let end_observer = CFRunLoopObserverCreate(
+      ptr::null_mut(),
+      kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+      1, // repeat = true
+      CFIndex::max_value(),
+      control_flow_end_handler,
+      ptr::null_mut(),
+    );
+    CFRunLoopAddObserver(main_loop, end_observer, kCFRunLoopDefaultMode);
+  }
 }
 
 #[derive(Debug)]
 pub enum Never {}
 
 pub trait EventHandler: Debug {
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
-    fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
+  fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
+  fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
 struct EventLoopHandler<F, T: 'static> {
-    f: F,
-    event_loop: RootEventLoopWindowTarget<T>,
+  f: F,
+  event_loop: RootEventLoopWindowTarget<T>,
 }
 
 impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopHandler")
-            .field("event_loop", &self.event_loop)
-            .finish()
-    }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.debug_struct("EventLoopHandler")
+      .field("event_loop", &self.event_loop)
+      .finish()
+  }
 }
 
 impl<F, T> EventHandler for EventLoopHandler<F, T>
 where
-    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
-    T: 'static,
+  F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+  T: 'static,
 {
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
-        (self.f)(
-            event.map_nonuser_event().unwrap(),
-            &self.event_loop,
-            control_flow,
-        );
-    }
+  fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
+    (self.f)(
+      event.map_nonuser_event().unwrap(),
+      &self.event_loop,
+      control_flow,
+    );
+  }
 
-    fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
-        for event in self.event_loop.p.receiver.try_iter() {
-            (self.f)(Event::UserEvent(event), &self.event_loop, control_flow);
-        }
+  fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
+    for event in self.event_loop.p.receiver.try_iter() {
+      (self.f)(Event::UserEvent(event), &self.event_loop, control_flow);
     }
+  }
 }
 
 // must be called on main thread
 pub unsafe fn get_idiom() -> Idiom {
-    let device: id = msg_send![class!(UIDevice), currentDevice];
-    let raw_idiom: UIUserInterfaceIdiom = msg_send![device, userInterfaceIdiom];
-    raw_idiom.into()
+  let device: id = msg_send![class!(UIDevice), currentDevice];
+  let raw_idiom: UIUserInterfaceIdiom = msg_send![device, userInterfaceIdiom];
+  raw_idiom.into()
 }

src/platform_impl/ios/ffi.rs

@@ -5,8 +5,8 @@ use std::{convert::TryInto, ffi::CString, ops::BitOr, os::raw::*};
 use objc::{runtime::Object, Encode, Encoding};
 
 use crate::{
-    dpi::LogicalSize,
-    platform::ios::{Idiom, ScreenEdge, ValidOrientations},
+  dpi::LogicalSize,
+  platform::ios::{Idiom, ScreenEdge, ValidOrientations},
 };
 
 pub type id = *mut Object;
@@ -23,96 +23,96 @@ pub type NSUInteger = usize;
 #[repr(C)]
 #[derive(Clone, Debug)]
 pub struct NSOperatingSystemVersion {
-    pub major: NSInteger,
-    pub minor: NSInteger,
-    pub patch: NSInteger,
+  pub major: NSInteger,
+  pub minor: NSInteger,
+  pub patch: NSInteger,
 }
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct CGPoint {
-    pub x: CGFloat,
-    pub y: CGFloat,
+  pub x: CGFloat,
+  pub y: CGFloat,
 }
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct CGSize {
-    pub width: CGFloat,
-    pub height: CGFloat,
+  pub width: CGFloat,
+  pub height: CGFloat,
 }
 
 impl CGSize {
-    pub fn new(size: LogicalSize<f64>) -> CGSize {
-        CGSize {
-            width: size.width as _,
-            height: size.height as _,
-        }
+  pub fn new(size: LogicalSize<f64>) -> CGSize {
+    CGSize {
+      width: size.width as _,
+      height: size.height as _,
     }
+  }
 }
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct CGRect {
-    pub origin: CGPoint,
-    pub size: CGSize,
+  pub origin: CGPoint,
+  pub size: CGSize,
 }
 
 impl CGRect {
-    pub fn new(origin: CGPoint, size: CGSize) -> CGRect {
-        CGRect { origin, size }
-    }
+  pub fn new(origin: CGPoint, size: CGSize) -> CGRect {
+    CGRect { origin, size }
+  }
 }
 
 unsafe impl Encode for CGRect {
-    fn encode() -> Encoding {
-        unsafe {
-            if cfg!(target_pointer_width = "32") {
-                Encoding::from_str("{CGRect={CGPoint=ff}{CGSize=ff}}")
-            } else if cfg!(target_pointer_width = "64") {
-                Encoding::from_str("{CGRect={CGPoint=dd}{CGSize=dd}}")
-            } else {
-                unimplemented!()
-            }
-        }
+  fn encode() -> Encoding {
+    unsafe {
+      if cfg!(target_pointer_width = "32") {
+        Encoding::from_str("{CGRect={CGPoint=ff}{CGSize=ff}}")
+      } else if cfg!(target_pointer_width = "64") {
+        Encoding::from_str("{CGRect={CGPoint=dd}{CGSize=dd}}")
+      } else {
+        unimplemented!()
+      }
     }
+  }
 }
 #[derive(Debug)]
 #[allow(dead_code)]
 #[repr(isize)]
 pub enum UITouchPhase {
-    Began = 0,
-    Moved,
-    Stationary,
-    Ended,
-    Cancelled,
+  Began = 0,
+  Moved,
+  Stationary,
+  Ended,
+  Cancelled,
 }
 
 #[derive(Debug, PartialEq)]
 #[allow(dead_code)]
 #[repr(isize)]
 pub enum UIForceTouchCapability {
-    Unknown = 0,
-    Unavailable,
-    Available,
+  Unknown = 0,
+  Unavailable,
+  Available,
 }
 
 #[derive(Debug, PartialEq)]
 #[allow(dead_code)]
 #[repr(isize)]
 pub enum UITouchType {
-    Direct = 0,
-    Indirect,
-    Pencil,
+  Direct = 0,
+  Indirect,
+  Pencil,
 }
 
 #[repr(C)]
 #[derive(Debug, Clone)]
 pub struct UIEdgeInsets {
-    pub top: CGFloat,
-    pub left: CGFloat,
-    pub bottom: CGFloat,
-    pub right: CGFloat,
+  pub top: CGFloat,
+  pub left: CGFloat,
+  pub bottom: CGFloat,
+  pub right: CGFloat,
 }
 
 #[repr(transparent)]
@@ -120,42 +120,42 @@ pub struct UIEdgeInsets {
 pub struct UIUserInterfaceIdiom(NSInteger);
 
 unsafe impl Encode for UIUserInterfaceIdiom {
-    fn encode() -> Encoding {
-        NSInteger::encode()
-    }
+  fn encode() -> Encoding {
+    NSInteger::encode()
+  }
 }
 
 impl UIUserInterfaceIdiom {
-    pub const Unspecified: UIUserInterfaceIdiom = UIUserInterfaceIdiom(-1);
-    pub const Phone: UIUserInterfaceIdiom = UIUserInterfaceIdiom(0);
-    pub const Pad: UIUserInterfaceIdiom = UIUserInterfaceIdiom(1);
-    pub const TV: UIUserInterfaceIdiom = UIUserInterfaceIdiom(2);
-    pub const CarPlay: UIUserInterfaceIdiom = UIUserInterfaceIdiom(3);
+  pub const Unspecified: UIUserInterfaceIdiom = UIUserInterfaceIdiom(-1);
+  pub const Phone: UIUserInterfaceIdiom = UIUserInterfaceIdiom(0);
+  pub const Pad: UIUserInterfaceIdiom = UIUserInterfaceIdiom(1);
+  pub const TV: UIUserInterfaceIdiom = UIUserInterfaceIdiom(2);
+  pub const CarPlay: UIUserInterfaceIdiom = UIUserInterfaceIdiom(3);
 }
 
 impl From<Idiom> for UIUserInterfaceIdiom {
-    fn from(idiom: Idiom) -> UIUserInterfaceIdiom {
-        match idiom {
-            Idiom::Unspecified => UIUserInterfaceIdiom::Unspecified,
-            Idiom::Phone => UIUserInterfaceIdiom::Phone,
-            Idiom::Pad => UIUserInterfaceIdiom::Pad,
-            Idiom::TV => UIUserInterfaceIdiom::TV,
-            Idiom::CarPlay => UIUserInterfaceIdiom::CarPlay,
-        }
+  fn from(idiom: Idiom) -> UIUserInterfaceIdiom {
+    match idiom {
+      Idiom::Unspecified => UIUserInterfaceIdiom::Unspecified,
+      Idiom::Phone => UIUserInterfaceIdiom::Phone,
+      Idiom::Pad => UIUserInterfaceIdiom::Pad,
+      Idiom::TV => UIUserInterfaceIdiom::TV,
+      Idiom::CarPlay => UIUserInterfaceIdiom::CarPlay,
     }
+  }
 }
 
 impl Into<Idiom> for UIUserInterfaceIdiom {
-    fn into(self) -> Idiom {
-        match self {
-            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
-            UIUserInterfaceIdiom::Phone => Idiom::Phone,
-            UIUserInterfaceIdiom::Pad => Idiom::Pad,
-            UIUserInterfaceIdiom::TV => Idiom::TV,
-            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
-            _ => unreachable!(),
-        }
+  fn into(self) -> Idiom {
+    match self {
+      UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
+      UIUserInterfaceIdiom::Phone => Idiom::Phone,
+      UIUserInterfaceIdiom::Pad => Idiom::Pad,
+      UIUserInterfaceIdiom::TV => Idiom::TV,
+      UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
+      _ => unreachable!(),
     }
+  }
 }
 
 #[repr(transparent)]
@@ -163,50 +163,49 @@ impl Into<Idiom> for UIUserInterfaceIdiom {
 pub struct UIInterfaceOrientationMask(NSUInteger);
 
 unsafe impl Encode for UIInterfaceOrientationMask {
-    fn encode() -> Encoding {
-        NSUInteger::encode()
-    }
+  fn encode() -> Encoding {
+    NSUInteger::encode()
+  }
 }
 
 impl UIInterfaceOrientationMask {
-    pub const Portrait: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 1);
-    pub const PortraitUpsideDown: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 2);
-    pub const LandscapeLeft: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 4);
-    pub const LandscapeRight: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 3);
-    pub const Landscape: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::LandscapeLeft.0 | Self::LandscapeRight.0);
-    pub const AllButUpsideDown: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::Landscape.0 | Self::Portrait.0);
-    pub const All: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::AllButUpsideDown.0 | Self::PortraitUpsideDown.0);
+  pub const Portrait: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 1);
+  pub const PortraitUpsideDown: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 2);
+  pub const LandscapeLeft: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 4);
+  pub const LandscapeRight: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 3);
+  pub const Landscape: UIInterfaceOrientationMask =
+    UIInterfaceOrientationMask(Self::LandscapeLeft.0 | Self::LandscapeRight.0);
+  pub const AllButUpsideDown: UIInterfaceOrientationMask =
+    UIInterfaceOrientationMask(Self::Landscape.0 | Self::Portrait.0);
+  pub const All: UIInterfaceOrientationMask =
+    UIInterfaceOrientationMask(Self::AllButUpsideDown.0 | Self::PortraitUpsideDown.0);
 }
 
 impl BitOr for UIInterfaceOrientationMask {
-    type Output = Self;
+  type Output = Self;
 
-    fn bitor(self, rhs: Self) -> Self {
-        UIInterfaceOrientationMask(self.0 | rhs.0)
-    }
+  fn bitor(self, rhs: Self) -> Self {
+    UIInterfaceOrientationMask(self.0 | rhs.0)
+  }
 }
 
 impl UIInterfaceOrientationMask {
-    pub fn from_valid_orientations_idiom(
-        valid_orientations: ValidOrientations,
-        idiom: Idiom,
-    ) -> UIInterfaceOrientationMask {
-        match (valid_orientations, idiom) {
-            (ValidOrientations::LandscapeAndPortrait, Idiom::Phone) => {
-                UIInterfaceOrientationMask::AllButUpsideDown
-            }
-            (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
-            (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
-            (ValidOrientations::Portrait, Idiom::Phone) => UIInterfaceOrientationMask::Portrait,
-            (ValidOrientations::Portrait, _) => {
-                UIInterfaceOrientationMask::Portrait
-                    | UIInterfaceOrientationMask::PortraitUpsideDown
-            }
-        }
+  pub fn from_valid_orientations_idiom(
+    valid_orientations: ValidOrientations,
+    idiom: Idiom,
+  ) -> UIInterfaceOrientationMask {
+    match (valid_orientations, idiom) {
+      (ValidOrientations::LandscapeAndPortrait, Idiom::Phone) => {
+        UIInterfaceOrientationMask::AllButUpsideDown
+      }
+      (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
+      (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
+      (ValidOrientations::Portrait, Idiom::Phone) => UIInterfaceOrientationMask::Portrait,
+      (ValidOrientations::Portrait, _) => {
+        UIInterfaceOrientationMask::Portrait | UIInterfaceOrientationMask::PortraitUpsideDown
+      }
     }
+  }
 }
 
 #[repr(transparent)]
@@ -214,27 +213,27 @@ impl UIInterfaceOrientationMask {
 pub struct UIRectEdge(NSUInteger);
 
 unsafe impl Encode for UIRectEdge {
-    fn encode() -> Encoding {
-        NSUInteger::encode()
-    }
+  fn encode() -> Encoding {
+    NSUInteger::encode()
+  }
 }
 
 impl From<ScreenEdge> for UIRectEdge {
-    fn from(screen_edge: ScreenEdge) -> UIRectEdge {
-        assert_eq!(
-            screen_edge.bits() & !ScreenEdge::ALL.bits(),
-            0,
-            "invalid `ScreenEdge`"
-        );
-        UIRectEdge(screen_edge.bits().into())
-    }
+  fn from(screen_edge: ScreenEdge) -> UIRectEdge {
+    assert_eq!(
+      screen_edge.bits() & !ScreenEdge::ALL.bits(),
+      0,
+      "invalid `ScreenEdge`"
+    );
+    UIRectEdge(screen_edge.bits().into())
+  }
 }
 
 impl Into<ScreenEdge> for UIRectEdge {
-    fn into(self) -> ScreenEdge {
-        let bits: u8 = self.0.try_into().expect("invalid `UIRectEdge`");
-        ScreenEdge::from_bits(bits).expect("invalid `ScreenEdge`")
-    }
+  fn into(self) -> ScreenEdge {
+    let bits: u8 = self.0.try_into().expect("invalid `UIRectEdge`");
+    ScreenEdge::from_bits(bits).expect("invalid `ScreenEdge`")
+  }
 }
 
 #[repr(transparent)]
@@ -242,72 +241,72 @@ impl Into<ScreenEdge> for UIRectEdge {
 pub struct UIScreenOverscanCompensation(NSInteger);
 
 unsafe impl Encode for UIScreenOverscanCompensation {
-    fn encode() -> Encoding {
-        NSInteger::encode()
-    }
+  fn encode() -> Encoding {
+    NSInteger::encode()
+  }
 }
 
 #[allow(dead_code)]
 impl UIScreenOverscanCompensation {
-    pub const Scale: UIScreenOverscanCompensation = UIScreenOverscanCompensation(0);
-    pub const InsetBounds: UIScreenOverscanCompensation = UIScreenOverscanCompensation(1);
-    pub const None: UIScreenOverscanCompensation = UIScreenOverscanCompensation(2);
+  pub const Scale: UIScreenOverscanCompensation = UIScreenOverscanCompensation(0);
+  pub const InsetBounds: UIScreenOverscanCompensation = UIScreenOverscanCompensation(1);
+  pub const None: UIScreenOverscanCompensation = UIScreenOverscanCompensation(2);
 }
 
 #[link(name = "UIKit", kind = "framework")]
 #[link(name = "CoreFoundation", kind = "framework")]
 extern "C" {
-    pub static kCFRunLoopDefaultMode: CFRunLoopMode;
-    pub static kCFRunLoopCommonModes: CFRunLoopMode;
+  pub static kCFRunLoopDefaultMode: CFRunLoopMode;
+  pub static kCFRunLoopCommonModes: CFRunLoopMode;
 
-    pub fn UIApplicationMain(
-        argc: c_int,
-        argv: *const c_char,
-        principalClassName: id,
-        delegateClassName: id,
-    ) -> c_int;
+  pub fn UIApplicationMain(
+    argc: c_int,
+    argv: *const c_char,
+    principalClassName: id,
+    delegateClassName: id,
+  ) -> c_int;
 
-    pub fn CFRunLoopGetMain() -> CFRunLoopRef;
-    pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
+  pub fn CFRunLoopGetMain() -> CFRunLoopRef;
+  pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
 
-    pub fn CFRunLoopObserverCreate(
-        allocator: CFAllocatorRef,
-        activities: CFOptionFlags,
-        repeats: Boolean,
-        order: CFIndex,
-        callout: CFRunLoopObserverCallBack,
-        context: *mut CFRunLoopObserverContext,
-    ) -> CFRunLoopObserverRef;
-    pub fn CFRunLoopAddObserver(
-        rl: CFRunLoopRef,
-        observer: CFRunLoopObserverRef,
-        mode: CFRunLoopMode,
-    );
+  pub fn CFRunLoopObserverCreate(
+    allocator: CFAllocatorRef,
+    activities: CFOptionFlags,
+    repeats: Boolean,
+    order: CFIndex,
+    callout: CFRunLoopObserverCallBack,
+    context: *mut CFRunLoopObserverContext,
+  ) -> CFRunLoopObserverRef;
+  pub fn CFRunLoopAddObserver(
+    rl: CFRunLoopRef,
+    observer: CFRunLoopObserverRef,
+    mode: CFRunLoopMode,
+  );
 
-    pub fn CFRunLoopTimerCreate(
-        allocator: CFAllocatorRef,
-        fireDate: CFAbsoluteTime,
-        interval: CFTimeInterval,
-        flags: CFOptionFlags,
-        order: CFIndex,
-        callout: CFRunLoopTimerCallBack,
-        context: *mut CFRunLoopTimerContext,
-    ) -> CFRunLoopTimerRef;
-    pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
-    pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
-    pub fn CFRunLoopTimerInvalidate(time: CFRunLoopTimerRef);
+  pub fn CFRunLoopTimerCreate(
+    allocator: CFAllocatorRef,
+    fireDate: CFAbsoluteTime,
+    interval: CFTimeInterval,
+    flags: CFOptionFlags,
+    order: CFIndex,
+    callout: CFRunLoopTimerCallBack,
+    context: *mut CFRunLoopTimerContext,
+  ) -> CFRunLoopTimerRef;
+  pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
+  pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
+  pub fn CFRunLoopTimerInvalidate(time: CFRunLoopTimerRef);
 
-    pub fn CFRunLoopSourceCreate(
-        allocator: CFAllocatorRef,
-        order: CFIndex,
-        context: *mut CFRunLoopSourceContext,
-    ) -> CFRunLoopSourceRef;
-    pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
-    pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
-    pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
+  pub fn CFRunLoopSourceCreate(
+    allocator: CFAllocatorRef,
+    order: CFIndex,
+    context: *mut CFRunLoopSourceContext,
+  ) -> CFRunLoopSourceRef;
+  pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
+  pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
+  pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
 
-    pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
-    pub fn CFRelease(cftype: *const c_void);
+  pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
+  pub fn CFRelease(cftype: *const c_void);
 }
 
 pub type Boolean = u8;
@@ -339,7 +338,7 @@ pub const kCFRunLoopAfterWaiting: CFRunLoopActivity = 1 << 6;
 pub const kCFRunLoopExit: CFRunLoopActivity = 1 << 7;
 
 pub type CFRunLoopObserverCallBack =
-    extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
+  extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
 pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void);
 
 pub enum CFRunLoopObserverContext {}
@@ -347,47 +346,47 @@ pub enum CFRunLoopTimerContext {}
 
 #[repr(C)]
 pub struct CFRunLoopSourceContext {
-    pub version: CFIndex,
-    pub info: *mut c_void,
-    pub retain: Option<extern "C" fn(*const c_void) -> *const c_void>,
-    pub release: Option<extern "C" fn(*const c_void)>,
-    pub copyDescription: Option<extern "C" fn(*const c_void) -> CFStringRef>,
-    pub equal: Option<extern "C" fn(*const c_void, *const c_void) -> Boolean>,
-    pub hash: Option<extern "C" fn(*const c_void) -> CFHashCode>,
-    pub schedule: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub cancel: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub perform: Option<extern "C" fn(*mut c_void)>,
+  pub version: CFIndex,
+  pub info: *mut c_void,
+  pub retain: Option<extern "C" fn(*const c_void) -> *const c_void>,
+  pub release: Option<extern "C" fn(*const c_void)>,
+  pub copyDescription: Option<extern "C" fn(*const c_void) -> CFStringRef>,
+  pub equal: Option<extern "C" fn(*const c_void, *const c_void) -> Boolean>,
+  pub hash: Option<extern "C" fn(*const c_void) -> CFHashCode>,
+  pub schedule: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
+  pub cancel: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
+  pub perform: Option<extern "C" fn(*mut c_void)>,
 }
 
 // This is named NSStringRust rather than NSString because the "Debug View Heirarchy" feature of
 // Xcode requires a non-ambiguous reference to NSString for unclear reasons. This makes Xcode happy
 // so please test if you change the name back to NSString.
 pub trait NSStringRust: Sized {
-    unsafe fn alloc(_: Self) -> id {
-        msg_send![class!(NSString), alloc]
-    }
+  unsafe fn alloc(_: Self) -> id {
+    msg_send![class!(NSString), alloc]
+  }
 
-    unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id;
-    unsafe fn stringByAppendingString_(self, other: id) -> id;
-    unsafe fn init_str(self, string: &str) -> Self;
-    unsafe fn UTF8String(self) -> *const c_char;
+  unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id;
+  unsafe fn stringByAppendingString_(self, other: id) -> id;
+  unsafe fn init_str(self, string: &str) -> Self;
+  unsafe fn UTF8String(self) -> *const c_char;
 }
 
 impl NSStringRust for id {
-    unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id {
-        msg_send![self, initWithUTF8String: c_string as id]
-    }
+  unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id {
+    msg_send![self, initWithUTF8String: c_string as id]
+  }
 
-    unsafe fn stringByAppendingString_(self, other: id) -> id {
-        msg_send![self, stringByAppendingString: other]
-    }
+  unsafe fn stringByAppendingString_(self, other: id) -> id {
+    msg_send![self, stringByAppendingString: other]
+  }
 
-    unsafe fn init_str(self, string: &str) -> id {
-        let cstring = CString::new(string).unwrap();
-        self.initWithUTF8String_(cstring.as_ptr())
-    }
+  unsafe fn init_str(self, string: &str) -> id {
+    let cstring = CString::new(string).unwrap();
+    self.initWithUTF8String_(cstring.as_ptr())
+  }
 
-    unsafe fn UTF8String(self) -> *const c_char {
-        msg_send![self, UTF8String]
-    }
+  unsafe fn UTF8String(self) -> *const c_char {
+    msg_send![self, UTF8String]
+  }
 }

src/platform_impl/ios/mod.rs

@@ -78,24 +78,24 @@ mod window;
 use std::fmt;
 
 pub use self::{
-    event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
-    monitor::{MonitorHandle, VideoMode},
-    window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},
+  event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
+  monitor::{MonitorHandle, VideoMode},
+  window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},
 };
 
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId {
-    uiscreen: ffi::id,
+  uiscreen: ffi::id,
 }
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
-        DeviceId {
-            uiscreen: std::ptr::null_mut(),
-        }
+  pub unsafe fn dummy() -> Self {
+    DeviceId {
+      uiscreen: std::ptr::null_mut(),
     }
+  }
 }
 
 unsafe impl Send for DeviceId {}
@@ -105,9 +105,9 @@ unsafe impl Sync for DeviceId {}
 pub enum OsError {}
 
 impl fmt::Display for OsError {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            _ => unreachable!(),
-        }
+  fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      _ => unreachable!(),
     }
+  }
 }

src/platform_impl/ios/monitor.rs

@@ -1,25 +1,25 @@
 use std::{
-    collections::{BTreeSet, VecDeque},
-    fmt,
-    ops::{Deref, DerefMut},
+  collections::{BTreeSet, VecDeque},
+  fmt,
+  ops::{Deref, DerefMut},
 };
 
 use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
-    platform_impl::platform::{
-        app_state,
-        ffi::{id, nil, CGFloat, CGRect, CGSize, NSInteger, NSUInteger},
-    },
+  dpi::{PhysicalPosition, PhysicalSize},
+  monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+  platform_impl::platform::{
+    app_state,
+    ffi::{id, nil, CGFloat, CGRect, CGSize, NSInteger, NSUInteger},
+  },
 };
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct VideoMode {
-    pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate: u16,
-    pub(crate) screen_mode: NativeDisplayMode,
-    pub(crate) monitor: MonitorHandle,
+  pub(crate) size: (u32, u32),
+  pub(crate) bit_depth: u16,
+  pub(crate) refresh_rate: u16,
+  pub(crate) screen_mode: NativeDisplayMode,
+  pub(crate) monitor: MonitorHandle,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -28,272 +28,268 @@ pub struct NativeDisplayMode(pub id);
 unsafe impl Send for NativeDisplayMode {}
 
 impl Drop for NativeDisplayMode {
-    fn drop(&mut self) {
-        unsafe {
-            let () = msg_send![self.0, release];
-        }
+  fn drop(&mut self) {
+    unsafe {
+      let () = msg_send![self.0, release];
     }
+  }
 }
 
 impl Clone for NativeDisplayMode {
-    fn clone(&self) -> Self {
-        unsafe {
-            let _: id = msg_send![self.0, retain];
-        }
-        NativeDisplayMode(self.0)
+  fn clone(&self) -> Self {
+    unsafe {
+      let _: id = msg_send![self.0, retain];
     }
+    NativeDisplayMode(self.0)
+  }
 }
 
 impl Clone for VideoMode {
-    fn clone(&self) -> VideoMode {
-        VideoMode {
-            size: self.size,
-            bit_depth: self.bit_depth,
-            refresh_rate: self.refresh_rate,
-            screen_mode: self.screen_mode.clone(),
-            monitor: self.monitor.clone(),
-        }
+  fn clone(&self) -> VideoMode {
+    VideoMode {
+      size: self.size,
+      bit_depth: self.bit_depth,
+      refresh_rate: self.refresh_rate,
+      screen_mode: self.screen_mode.clone(),
+      monitor: self.monitor.clone(),
     }
+  }
 }
 
 impl VideoMode {
-    unsafe fn retained_new(uiscreen: id, screen_mode: id) -> VideoMode {
-        assert_main_thread!("`VideoMode` can only be created on the main thread on iOS");
-        let os_capabilities = app_state::os_capabilities();
-        let refresh_rate: NSInteger = if os_capabilities.maximum_frames_per_second {
-            msg_send![uiscreen, maximumFramesPerSecond]
-        } else {
-            // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
-            // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
-            //
-            // All iOS devices support 60 fps, and on devices where `maximumFramesPerSecond` is not
-            // supported, they are all guaranteed to have 60hz refresh rates. This does not
-            // correctly handle external displays. ProMotion displays support 120fps, but they were
-            // introduced at the same time as the `maximumFramesPerSecond` API.
-            //
-            // FIXME: earlier OSs could calculate the refresh rate using
-            // `-[CADisplayLink duration]`.
-            os_capabilities.maximum_frames_per_second_err_msg("defaulting to 60 fps");
-            60
-        };
-        let size: CGSize = msg_send![screen_mode, size];
-        let screen_mode: id = msg_send![screen_mode, retain];
-        let screen_mode = NativeDisplayMode(screen_mode);
-        VideoMode {
-            size: (size.width as u32, size.height as u32),
-            bit_depth: 32,
-            refresh_rate: refresh_rate as u16,
-            screen_mode,
-            monitor: MonitorHandle::retained_new(uiscreen),
-        }
+  unsafe fn retained_new(uiscreen: id, screen_mode: id) -> VideoMode {
+    assert_main_thread!("`VideoMode` can only be created on the main thread on iOS");
+    let os_capabilities = app_state::os_capabilities();
+    let refresh_rate: NSInteger = if os_capabilities.maximum_frames_per_second {
+      msg_send![uiscreen, maximumFramesPerSecond]
+    } else {
+      // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
+      // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
+      //
+      // All iOS devices support 60 fps, and on devices where `maximumFramesPerSecond` is not
+      // supported, they are all guaranteed to have 60hz refresh rates. This does not
+      // correctly handle external displays. ProMotion displays support 120fps, but they were
+      // introduced at the same time as the `maximumFramesPerSecond` API.
+      //
+      // FIXME: earlier OSs could calculate the refresh rate using
+      // `-[CADisplayLink duration]`.
+      os_capabilities.maximum_frames_per_second_err_msg("defaulting to 60 fps");
+      60
+    };
+    let size: CGSize = msg_send![screen_mode, size];
+    let screen_mode: id = msg_send![screen_mode, retain];
+    let screen_mode = NativeDisplayMode(screen_mode);
+    VideoMode {
+      size: (size.width as u32, size.height as u32),
+      bit_depth: 32,
+      refresh_rate: refresh_rate as u16,
+      screen_mode,
+      monitor: MonitorHandle::retained_new(uiscreen),
     }
+  }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.size.into()
-    }
+  pub fn size(&self) -> PhysicalSize<u32> {
+    self.size.into()
+  }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
-    }
+  pub fn bit_depth(&self) -> u16 {
+    self.bit_depth
+  }
 
-    pub fn refresh_rate(&self) -> u16 {
-        self.refresh_rate
-    }
+  pub fn refresh_rate(&self) -> u16 {
+    self.refresh_rate
+  }
 
-    pub fn monitor(&self) -> RootMonitorHandle {
-        RootMonitorHandle {
-            inner: self.monitor.clone(),
-        }
+  pub fn monitor(&self) -> RootMonitorHandle {
+    RootMonitorHandle {
+      inner: self.monitor.clone(),
     }
+  }
 }
 
 #[derive(PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Inner {
-    uiscreen: id,
+  uiscreen: id,
 }
 
 impl Drop for Inner {
-    fn drop(&mut self) {
-        unsafe {
-            let () = msg_send![self.uiscreen, release];
-        }
+  fn drop(&mut self) {
+    unsafe {
+      let () = msg_send![self.uiscreen, release];
     }
+  }
 }
 
 #[derive(PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct MonitorHandle {
-    inner: Inner,
+  inner: Inner,
 }
 
 impl Deref for MonitorHandle {
-    type Target = Inner;
+  type Target = Inner;
 
-    fn deref(&self) -> &Inner {
-        unsafe {
-            assert_main_thread!(
-                "`MonitorHandle` methods can only be run on the main thread on iOS"
-            );
-        }
-        &self.inner
+  fn deref(&self) -> &Inner {
+    unsafe {
+      assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
     }
+    &self.inner
+  }
 }
 
 impl DerefMut for MonitorHandle {
-    fn deref_mut(&mut self) -> &mut Inner {
-        unsafe {
-            assert_main_thread!(
-                "`MonitorHandle` methods can only be run on the main thread on iOS"
-            );
-        }
-        &mut self.inner
+  fn deref_mut(&mut self) -> &mut Inner {
+    unsafe {
+      assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
     }
+    &mut self.inner
+  }
 }
 
 unsafe impl Send for MonitorHandle {}
 unsafe impl Sync for MonitorHandle {}
 
 impl Clone for MonitorHandle {
-    fn clone(&self) -> MonitorHandle {
-        MonitorHandle::retained_new(self.uiscreen)
-    }
+  fn clone(&self) -> MonitorHandle {
+    MonitorHandle::retained_new(self.uiscreen)
+  }
 }
 
 impl Drop for MonitorHandle {
-    fn drop(&mut self) {
-        unsafe {
-            assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
-        }
+  fn drop(&mut self) {
+    unsafe {
+      assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
     }
+  }
 }
 
 impl fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        #[derive(Debug)]
-        struct MonitorHandle {
-            name: Option<String>,
-            size: PhysicalSize<u32>,
-            position: PhysicalPosition<i32>,
-            scale_factor: f64,
-        }
-
-        let monitor_id_proxy = MonitorHandle {
-            name: self.name(),
-            size: self.size(),
-            position: self.position(),
-            scale_factor: self.scale_factor(),
-        };
-
-        monitor_id_proxy.fmt(f)
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    #[derive(Debug)]
+    struct MonitorHandle {
+      name: Option<String>,
+      size: PhysicalSize<u32>,
+      position: PhysicalPosition<i32>,
+      scale_factor: f64,
     }
+
+    let monitor_id_proxy = MonitorHandle {
+      name: self.name(),
+      size: self.size(),
+      position: self.position(),
+      scale_factor: self.scale_factor(),
+    };
+
+    monitor_id_proxy.fmt(f)
+  }
 }
 
 impl MonitorHandle {
-    pub fn retained_new(uiscreen: id) -> MonitorHandle {
-        unsafe {
-            assert_main_thread!("`MonitorHandle` can only be cloned on the main thread on iOS");
-            let () = msg_send![uiscreen, retain];
-        }
-        MonitorHandle {
-            inner: Inner { uiscreen },
-        }
+  pub fn retained_new(uiscreen: id) -> MonitorHandle {
+    unsafe {
+      assert_main_thread!("`MonitorHandle` can only be cloned on the main thread on iOS");
+      let () = msg_send![uiscreen, retain];
     }
+    MonitorHandle {
+      inner: Inner { uiscreen },
+    }
+  }
 }
 
 impl Inner {
-    pub fn name(&self) -> Option<String> {
-        unsafe {
-            let main = main_uiscreen();
-            if self.uiscreen == main.uiscreen {
-                Some("Primary".to_string())
-            } else if self.uiscreen == mirrored_uiscreen(&main).uiscreen {
-                Some("Mirrored".to_string())
-            } else {
-                uiscreens()
-                    .iter()
-                    .position(|rhs| rhs.uiscreen == self.uiscreen)
-                    .map(|idx| idx.to_string())
-            }
-        }
+  pub fn name(&self) -> Option<String> {
+    unsafe {
+      let main = main_uiscreen();
+      if self.uiscreen == main.uiscreen {
+        Some("Primary".to_string())
+      } else if self.uiscreen == mirrored_uiscreen(&main).uiscreen {
+        Some("Mirrored".to_string())
+      } else {
+        uiscreens()
+          .iter()
+          .position(|rhs| rhs.uiscreen == self.uiscreen)
+          .map(|idx| idx.to_string())
+      }
+    }
+  }
+
+  pub fn size(&self) -> PhysicalSize<u32> {
+    unsafe {
+      let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
+      PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
+    }
+  }
+
+  pub fn position(&self) -> PhysicalPosition<i32> {
+    unsafe {
+      let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
+      (bounds.origin.x as f64, bounds.origin.y as f64).into()
+    }
+  }
+
+  pub fn scale_factor(&self) -> f64 {
+    unsafe {
+      let scale: CGFloat = msg_send![self.ui_screen(), nativeScale];
+      scale as f64
+    }
+  }
+
+  pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
+    let mut modes = BTreeSet::new();
+    unsafe {
+      let available_modes: id = msg_send![self.uiscreen, availableModes];
+      let available_mode_count: NSUInteger = msg_send![available_modes, count];
+
+      for i in 0..available_mode_count {
+        let mode: id = msg_send![available_modes, objectAtIndex: i];
+        modes.insert(RootVideoMode {
+          video_mode: VideoMode::retained_new(self.uiscreen, mode),
+        });
+      }
     }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        unsafe {
-            let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
-            PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
-        }
-    }
-
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        unsafe {
-            let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
-            (bounds.origin.x as f64, bounds.origin.y as f64).into()
-        }
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        unsafe {
-            let scale: CGFloat = msg_send![self.ui_screen(), nativeScale];
-            scale as f64
-        }
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
-        let mut modes = BTreeSet::new();
-        unsafe {
-            let available_modes: id = msg_send![self.uiscreen, availableModes];
-            let available_mode_count: NSUInteger = msg_send![available_modes, count];
-
-            for i in 0..available_mode_count {
-                let mode: id = msg_send![available_modes, objectAtIndex: i];
-                modes.insert(RootVideoMode {
-                    video_mode: VideoMode::retained_new(self.uiscreen, mode),
-                });
-            }
-        }
-
-        modes.into_iter()
-    }
+    modes.into_iter()
+  }
 }
 
 // MonitorHandleExtIOS
 impl Inner {
-    pub fn ui_screen(&self) -> id {
-        self.uiscreen
-    }
+  pub fn ui_screen(&self) -> id {
+    self.uiscreen
+  }
 
-    pub fn preferred_video_mode(&self) -> RootVideoMode {
-        unsafe {
-            let mode: id = msg_send![self.uiscreen, preferredMode];
-            RootVideoMode {
-                video_mode: VideoMode::retained_new(self.uiscreen, mode),
-            }
-        }
+  pub fn preferred_video_mode(&self) -> RootVideoMode {
+    unsafe {
+      let mode: id = msg_send![self.uiscreen, preferredMode];
+      RootVideoMode {
+        video_mode: VideoMode::retained_new(self.uiscreen, mode),
+      }
     }
+  }
 }
 
 // requires being run on main thread
 pub unsafe fn main_uiscreen() -> MonitorHandle {
-    let uiscreen: id = msg_send![class!(UIScreen), mainScreen];
-    MonitorHandle::retained_new(uiscreen)
+  let uiscreen: id = msg_send![class!(UIScreen), mainScreen];
+  MonitorHandle::retained_new(uiscreen)
 }
 
 // requires being run on main thread
 unsafe fn mirrored_uiscreen(monitor: &MonitorHandle) -> MonitorHandle {
-    let uiscreen: id = msg_send![monitor.uiscreen, mirroredScreen];
-    MonitorHandle::retained_new(uiscreen)
+  let uiscreen: id = msg_send![monitor.uiscreen, mirroredScreen];
+  MonitorHandle::retained_new(uiscreen)
 }
 
 // requires being run on main thread
 pub unsafe fn uiscreens() -> VecDeque<MonitorHandle> {
-    let screens: id = msg_send![class!(UIScreen), screens];
-    let count: NSUInteger = msg_send![screens, count];
-    let mut result = VecDeque::with_capacity(count as _);
-    let screens_enum: id = msg_send![screens, objectEnumerator];
-    loop {
-        let screen: id = msg_send![screens_enum, nextObject];
-        if screen == nil {
-            break result;
-        }
-        result.push_back(MonitorHandle::retained_new(screen));
+  let screens: id = msg_send![class!(UIScreen), screens];
+  let count: NSUInteger = msg_send![screens, count];
+  let mut result = VecDeque::with_capacity(count as _);
+  let screens_enum: id = msg_send![screens, objectEnumerator];
+  loop {
+    let screen: id = msg_send![screens_enum, nextObject];
+    if screen == nil {
+      break result;
     }
+    result.push_back(MonitorHandle::retained_new(screen));
+  }
 }

src/platform_impl/linux/mod.rs

@@ -1,9 +1,9 @@
 #![cfg(any(
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
+  target_os = "linux",
+  target_os = "dragonfly",
+  target_os = "freebsd",
+  target_os = "netbsd",
+  target_os = "openbsd"
 ))]
 
 mod event_loop;
@@ -12,22 +12,24 @@ mod window;
 
 pub use event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
 pub use monitor::{MonitorHandle, VideoMode};
-pub use window::{PlatformIcon, PlatformSpecificWindowBuilderAttributes, Window, WindowId, hit_test};
+pub use window::{
+  hit_test, PlatformIcon, PlatformSpecificWindowBuilderAttributes, Window, WindowId,
+};
 
 #[derive(Debug, Clone)]
 pub struct OsError;
 
 impl std::fmt::Display for OsError {
-    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        Ok(())
-    }
+  fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+    Ok(())
+  }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(usize);
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
-        Self(0)
-    }
+  pub unsafe fn dummy() -> Self {
+    Self(0)
+  }
 }

src/platform_impl/linux/monitor.rs

@@ -1,59 +1,59 @@
 use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+  dpi::{PhysicalPosition, PhysicalSize},
+  monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MonitorHandle;
 
 impl MonitorHandle {
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        todo!()
-    }
+  #[inline]
+  pub fn name(&self) -> Option<String> {
+    todo!()
+  }
 
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        todo!()
-    }
+  #[inline]
+  pub fn size(&self) -> PhysicalSize<u32> {
+    todo!()
+  }
 
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        todo!()
-    }
+  #[inline]
+  pub fn position(&self) -> PhysicalPosition<i32> {
+    todo!()
+  }
 
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        todo!()
-    }
+  #[inline]
+  pub fn scale_factor(&self) -> f64 {
+    todo!()
+  }
 
-    #[inline]
-    pub fn video_modes(&self) -> Box<dyn Iterator<Item = RootVideoMode>> {
-        todo!()
-    }
+  #[inline]
+  pub fn video_modes(&self) -> Box<dyn Iterator<Item = RootVideoMode>> {
+    todo!()
+  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct VideoMode;
 
 impl VideoMode {
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        todo!()
-    }
+  #[inline]
+  pub fn size(&self) -> PhysicalSize<u32> {
+    todo!()
+  }
 
-    #[inline]
-    pub fn bit_depth(&self) -> u16 {
-        todo!()
-    }
+  #[inline]
+  pub fn bit_depth(&self) -> u16 {
+    todo!()
+  }
 
-    #[inline]
-    pub fn refresh_rate(&self) -> u16 {
-        todo!()
-    }
+  #[inline]
+  pub fn refresh_rate(&self) -> u16 {
+    todo!()
+  }
 
-    #[inline]
-    pub fn monitor(&self) -> RootMonitorHandle {
-        todo!()
-    }
+  #[inline]
+  pub fn monitor(&self) -> RootMonitorHandle {
+    todo!()
+  }
 }

src/platform_impl/macos/app.rs

@@ -1,12 +1,12 @@
 use std::collections::VecDeque;
 
 use cocoa::{
-    appkit::{self, NSEvent},
-    base::id,
+  appkit::{self, NSEvent},
+  base::id,
 };
 use objc::{
-    declare::ClassDecl,
-    runtime::{Class, Object, Sel},
+  declare::ClassDecl,
+  runtime::{Class, Object, Sel},
 };
 
 use super::{app_state::AppState, event::EventWrapper, util, DEVICE_ID};
@@ -17,114 +17,114 @@ unsafe impl Send for AppClass {}
 unsafe impl Sync for AppClass {}
 
 lazy_static! {
-    pub static ref APP_CLASS: AppClass = unsafe {
-        let superclass = class!(NSApplication);
-        let mut decl = ClassDecl::new("WinitApp", superclass).unwrap();
+  pub static ref APP_CLASS: AppClass = unsafe {
+    let superclass = class!(NSApplication);
+    let mut decl = ClassDecl::new("WinitApp", superclass).unwrap();
 
-        decl.add_method(
-            sel!(sendEvent:),
-            send_event as extern "C" fn(&Object, Sel, id),
-        );
+    decl.add_method(
+      sel!(sendEvent:),
+      send_event as extern "C" fn(&Object, Sel, id),
+    );
 
-        AppClass(decl.register())
-    };
+    AppClass(decl.register())
+  };
 }
 
 // Normally, holding Cmd + any key never sends us a `keyUp` event for that key.
 // Overriding `sendEvent:` like this fixes that. (https://stackoverflow.com/a/15294196)
 // Fun fact: Firefox still has this bug! (https://bugzilla.mozilla.org/show_bug.cgi?id=1299553)
 extern "C" fn send_event(this: &Object, _sel: Sel, event: id) {
-    unsafe {
-        // For posterity, there are some undocumented event types
-        // (https://github.com/servo/cocoa-rs/issues/155)
-        // but that doesn't really matter here.
-        let event_type = event.eventType();
-        let modifier_flags = event.modifierFlags();
-        if event_type == appkit::NSKeyUp
-            && util::has_flag(
-                modifier_flags,
-                appkit::NSEventModifierFlags::NSCommandKeyMask,
-            )
-        {
-            let key_window: id = msg_send![this, keyWindow];
-            let _: () = msg_send![key_window, sendEvent: event];
-        } else {
-            maybe_dispatch_device_event(event);
-            let superclass = util::superclass(this);
-            let _: () = msg_send![super(this, superclass), sendEvent: event];
-        }
+  unsafe {
+    // For posterity, there are some undocumented event types
+    // (https://github.com/servo/cocoa-rs/issues/155)
+    // but that doesn't really matter here.
+    let event_type = event.eventType();
+    let modifier_flags = event.modifierFlags();
+    if event_type == appkit::NSKeyUp
+      && util::has_flag(
+        modifier_flags,
+        appkit::NSEventModifierFlags::NSCommandKeyMask,
+      )
+    {
+      let key_window: id = msg_send![this, keyWindow];
+      let _: () = msg_send![key_window, sendEvent: event];
+    } else {
+      maybe_dispatch_device_event(event);
+      let superclass = util::superclass(this);
+      let _: () = msg_send![super(this, superclass), sendEvent: event];
     }
+  }
 }
 
 unsafe fn maybe_dispatch_device_event(event: id) {
-    let event_type = event.eventType();
-    match event_type {
-        appkit::NSMouseMoved
-        | appkit::NSLeftMouseDragged
-        | appkit::NSOtherMouseDragged
-        | appkit::NSRightMouseDragged => {
-            let mut events = VecDeque::with_capacity(3);
+  let event_type = event.eventType();
+  match event_type {
+    appkit::NSMouseMoved
+    | appkit::NSLeftMouseDragged
+    | appkit::NSOtherMouseDragged
+    | appkit::NSRightMouseDragged => {
+      let mut events = VecDeque::with_capacity(3);
 
-            let delta_x = event.deltaX() as f64;
-            let delta_y = event.deltaY() as f64;
+      let delta_x = event.deltaX() as f64;
+      let delta_y = event.deltaY() as f64;
 
-            if delta_x != 0.0 {
-                events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
-                    device_id: DEVICE_ID,
-                    event: DeviceEvent::Motion {
-                        axis: 0,
-                        value: delta_x,
-                    },
-                }));
-            }
+      if delta_x != 0.0 {
+        events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
+          device_id: DEVICE_ID,
+          event: DeviceEvent::Motion {
+            axis: 0,
+            value: delta_x,
+          },
+        }));
+      }
 
-            if delta_y != 0.0 {
-                events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
-                    device_id: DEVICE_ID,
-                    event: DeviceEvent::Motion {
-                        axis: 1,
-                        value: delta_y,
-                    },
-                }));
-            }
+      if delta_y != 0.0 {
+        events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
+          device_id: DEVICE_ID,
+          event: DeviceEvent::Motion {
+            axis: 1,
+            value: delta_y,
+          },
+        }));
+      }
 
-            if delta_x != 0.0 || delta_y != 0.0 {
-                events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
-                    device_id: DEVICE_ID,
-                    event: DeviceEvent::MouseMotion {
-                        delta: (delta_x, delta_y),
-                    },
-                }));
-            }
+      if delta_x != 0.0 || delta_y != 0.0 {
+        events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
+          device_id: DEVICE_ID,
+          event: DeviceEvent::MouseMotion {
+            delta: (delta_x, delta_y),
+          },
+        }));
+      }
 
-            AppState::queue_events(events);
-        }
-        appkit::NSLeftMouseDown | appkit::NSRightMouseDown | appkit::NSOtherMouseDown => {
-            let mut events = VecDeque::with_capacity(1);
-
-            events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
-                device_id: DEVICE_ID,
-                event: DeviceEvent::Button {
-                    button: event.buttonNumber() as u32,
-                    state: ElementState::Pressed,
-                },
-            }));
-
-            AppState::queue_events(events);
-        }
-        appkit::NSLeftMouseUp | appkit::NSRightMouseUp | appkit::NSOtherMouseUp => {
-            let mut events = VecDeque::with_capacity(1);
-
-            events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
-                device_id: DEVICE_ID,
-                event: DeviceEvent::Button {
-                    button: event.buttonNumber() as u32,
-                    state: ElementState::Released,
-                },
-            }));
-
-            AppState::queue_events(events);
-        }
-        _ => (),
+      AppState::queue_events(events);
     }
+    appkit::NSLeftMouseDown | appkit::NSRightMouseDown | appkit::NSOtherMouseDown => {
+      let mut events = VecDeque::with_capacity(1);
+
+      events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
+        device_id: DEVICE_ID,
+        event: DeviceEvent::Button {
+          button: event.buttonNumber() as u32,
+          state: ElementState::Pressed,
+        },
+      }));
+
+      AppState::queue_events(events);
+    }
+    appkit::NSLeftMouseUp | appkit::NSRightMouseUp | appkit::NSOtherMouseUp => {
+      let mut events = VecDeque::with_capacity(1);
+
+      events.push_back(EventWrapper::StaticEvent(Event::DeviceEvent {
+        device_id: DEVICE_ID,
+        event: DeviceEvent::Button {
+          button: event.buttonNumber() as u32,
+          state: ElementState::Released,
+        },
+      }));
+
+      AppState::queue_events(events);
+    }
+    _ => (),
+  }
 }

src/platform_impl/macos/app_delegate.rs

@@ -2,23 +2,23 @@ use crate::{platform::macos::ActivationPolicy, platform_impl::platform::app_stat
 
 use cocoa::base::id;
 use objc::{
-    declare::ClassDecl,
-    runtime::{Class, Object, Sel},
+  declare::ClassDecl,
+  runtime::{Class, Object, Sel},
 };
 use std::{
-    cell::{RefCell, RefMut},
-    os::raw::c_void,
+  cell::{RefCell, RefMut},
+  os::raw::c_void,
 };
 
 static AUX_DELEGATE_STATE_NAME: &str = "auxState";
 
 pub struct AuxDelegateState {
-    /// We store this value in order to be able to defer setting the activation policy until
-    /// after the app has finished launching. If the activation policy is set earlier, the
-    /// menubar is initially unresponsive on macOS 10.15 for example.
-    pub activation_policy: ActivationPolicy,
+  /// We store this value in order to be able to defer setting the activation policy until
+  /// after the app has finished launching. If the activation policy is set earlier, the
+  /// menubar is initially unresponsive on macOS 10.15 for example.
+  pub activation_policy: ActivationPolicy,
 
-    pub create_default_menu: bool,
+  pub create_default_menu: bool,
 }
 
 pub struct AppDelegateClass(pub *const Class);
@@ -26,56 +26,56 @@ unsafe impl Send for AppDelegateClass {}
 unsafe impl Sync for AppDelegateClass {}
 
 lazy_static! {
-    pub static ref APP_DELEGATE_CLASS: AppDelegateClass = unsafe {
-        let superclass = class!(NSResponder);
-        let mut decl = ClassDecl::new("WinitAppDelegate", superclass).unwrap();
+  pub static ref APP_DELEGATE_CLASS: AppDelegateClass = unsafe {
+    let superclass = class!(NSResponder);
+    let mut decl = ClassDecl::new("WinitAppDelegate", superclass).unwrap();
 
-        decl.add_class_method(sel!(new), new as extern "C" fn(&Class, Sel) -> id);
-        decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
+    decl.add_class_method(sel!(new), new as extern "C" fn(&Class, Sel) -> id);
+    decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
 
-        decl.add_method(
-            sel!(applicationDidFinishLaunching:),
-            did_finish_launching as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_ivar::<*mut c_void>(AUX_DELEGATE_STATE_NAME);
+    decl.add_method(
+      sel!(applicationDidFinishLaunching:),
+      did_finish_launching as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_ivar::<*mut c_void>(AUX_DELEGATE_STATE_NAME);
 
-        AppDelegateClass(decl.register())
-    };
+    AppDelegateClass(decl.register())
+  };
 }
 
 /// Safety: Assumes that Object is an instance of APP_DELEGATE_CLASS
 pub unsafe fn get_aux_state_mut(this: &Object) -> RefMut<'_, AuxDelegateState> {
-    let ptr: *mut c_void = *this.get_ivar(AUX_DELEGATE_STATE_NAME);
-    // Watch out that this needs to be the correct type
-    (*(ptr as *mut RefCell<AuxDelegateState>)).borrow_mut()
+  let ptr: *mut c_void = *this.get_ivar(AUX_DELEGATE_STATE_NAME);
+  // Watch out that this needs to be the correct type
+  (*(ptr as *mut RefCell<AuxDelegateState>)).borrow_mut()
 }
 
 extern "C" fn new(class: &Class, _: Sel) -> id {
-    unsafe {
-        let this: id = msg_send![class, alloc];
-        let this: id = msg_send![this, init];
-        (*this).set_ivar(
-            AUX_DELEGATE_STATE_NAME,
-            Box::into_raw(Box::new(RefCell::new(AuxDelegateState {
-                activation_policy: ActivationPolicy::Regular,
-                create_default_menu: true,
-            }))) as *mut c_void,
-        );
-        this
-    }
+  unsafe {
+    let this: id = msg_send![class, alloc];
+    let this: id = msg_send![this, init];
+    (*this).set_ivar(
+      AUX_DELEGATE_STATE_NAME,
+      Box::into_raw(Box::new(RefCell::new(AuxDelegateState {
+        activation_policy: ActivationPolicy::Regular,
+        create_default_menu: true,
+      }))) as *mut c_void,
+    );
+    this
+  }
 }
 
 extern "C" fn dealloc(this: &Object, _: Sel) {
-    unsafe {
-        let state_ptr: *mut c_void = *(this.get_ivar(AUX_DELEGATE_STATE_NAME));
-        // As soon as the box is constructed it is immediately dropped, releasing the underlying
-        // memory
-        Box::from_raw(state_ptr as *mut RefCell<AuxDelegateState>);
-    }
+  unsafe {
+    let state_ptr: *mut c_void = *(this.get_ivar(AUX_DELEGATE_STATE_NAME));
+    // As soon as the box is constructed it is immediately dropped, releasing the underlying
+    // memory
+    Box::from_raw(state_ptr as *mut RefCell<AuxDelegateState>);
+  }
 }
 
 extern "C" fn did_finish_launching(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `applicationDidFinishLaunching`");
-    AppState::launched(this);
-    trace!("Completed `applicationDidFinishLaunching`");
+  trace!("Triggered `applicationDidFinishLaunching`");
+  AppState::launched(this);
+  trace!("Completed `applicationDidFinishLaunching`");
 }

src/platform_impl/macos/app_state.rs

@@ -1,259 +1,257 @@
 use std::{
-    cell::{RefCell, RefMut},
-    collections::VecDeque,
-    fmt::{self, Debug},
-    hint::unreachable_unchecked,
-    mem,
-    rc::{Rc, Weak},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Mutex, MutexGuard,
-    },
-    time::Instant,
+  cell::{RefCell, RefMut},
+  collections::VecDeque,
+  fmt::{self, Debug},
+  hint::unreachable_unchecked,
+  mem,
+  rc::{Rc, Weak},
+  sync::{
+    atomic::{AtomicBool, Ordering},
+    Mutex, MutexGuard,
+  },
+  time::Instant,
 };
 
 use cocoa::{
-    appkit::{NSApp, NSApplication, NSWindow},
-    base::{id, nil},
-    foundation::{NSAutoreleasePool, NSSize},
+  appkit::{NSApp, NSApplication, NSWindow},
+  base::{id, nil},
+  foundation::{NSAutoreleasePool, NSSize},
 };
 use objc::runtime::YES;
 
 use objc::runtime::Object;
 
 use crate::{
-    dpi::LogicalSize,
-    event::{Event, StartCause, WindowEvent},
-    event_loop::{ControlFlow, EventLoopWindowTarget as RootWindowTarget},
-    platform::macos::ActivationPolicy,
-    platform_impl::{
-        get_aux_state_mut,
-        platform::{
-            event::{EventProxy, EventWrapper},
-            event_loop::{post_dummy_event, PanicInfo},
-            menu,
-            observer::{CFRunLoopGetMain, CFRunLoopWakeUp, EventLoopWaker},
-            util::{IdRef, Never},
-            window::get_window_id,
-        },
+  dpi::LogicalSize,
+  event::{Event, StartCause, WindowEvent},
+  event_loop::{ControlFlow, EventLoopWindowTarget as RootWindowTarget},
+  platform::macos::ActivationPolicy,
+  platform_impl::{
+    get_aux_state_mut,
+    platform::{
+      event::{EventProxy, EventWrapper},
+      event_loop::{post_dummy_event, PanicInfo},
+      menu,
+      observer::{CFRunLoopGetMain, CFRunLoopWakeUp, EventLoopWaker},
+      util::{IdRef, Never},
+      window::get_window_id,
     },
-    window::WindowId,
+  },
+  window::WindowId,
 };
 
 lazy_static! {
-    static ref HANDLER: Handler = Default::default();
+  static ref HANDLER: Handler = Default::default();
 }
 
 impl<'a, Never> Event<'a, Never> {
-    fn userify<T: 'static>(self) -> Event<'a, T> {
-        self.map_nonuser_event()
-            // `Never` can't be constructed, so the `UserEvent` variant can't
-            // be present here.
-            .unwrap_or_else(|_| unsafe { unreachable_unchecked() })
-    }
+  fn userify<T: 'static>(self) -> Event<'a, T> {
+    self
+      .map_nonuser_event()
+      // `Never` can't be constructed, so the `UserEvent` variant can't
+      // be present here.
+      .unwrap_or_else(|_| unsafe { unreachable_unchecked() })
+  }
 }
 
 pub trait EventHandler: Debug {
-    // Not sure probably it should accept Event<'static, Never>
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
-    fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
+  // Not sure probably it should accept Event<'static, Never>
+  fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
+  fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
 struct EventLoopHandler<T: 'static> {
-    callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
-    will_exit: bool,
-    window_target: Rc<RootWindowTarget<T>>,
+  callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+  will_exit: bool,
+  window_target: Rc<RootWindowTarget<T>>,
 }
 
 impl<T> EventLoopHandler<T> {
-    fn with_callback<F>(&mut self, f: F)
-    where
-        F: FnOnce(
-            &mut EventLoopHandler<T>,
-            RefMut<'_, dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
-        ),
-    {
-        if let Some(callback) = self.callback.upgrade() {
-            let callback = callback.borrow_mut();
-            (f)(self, callback);
-        } else {
-            panic!(
-                "Tried to dispatch an event, but the event loop that \
+  fn with_callback<F>(&mut self, f: F)
+  where
+    F: FnOnce(
+      &mut EventLoopHandler<T>,
+      RefMut<'_, dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
+    ),
+  {
+    if let Some(callback) = self.callback.upgrade() {
+      let callback = callback.borrow_mut();
+      (f)(self, callback);
+    } else {
+      panic!(
+        "Tried to dispatch an event, but the event loop that \
                 owned the event handler callback seems to be destroyed"
-            );
-        }
+      );
     }
+  }
 }
 
 impl<T> Debug for EventLoopHandler<T> {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter
-            .debug_struct("EventLoopHandler")
-            .field("window_target", &self.window_target)
-            .finish()
-    }
+  fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+    formatter
+      .debug_struct("EventLoopHandler")
+      .field("window_target", &self.window_target)
+      .finish()
+  }
 }
 
 impl<T> EventHandler for EventLoopHandler<T> {
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
-        self.with_callback(|this, mut callback| {
-            (callback)(event.userify(), &this.window_target, control_flow);
-            this.will_exit |= *control_flow == ControlFlow::Exit;
-            if this.will_exit {
-                *control_flow = ControlFlow::Exit;
-            }
-        });
-    }
+  fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
+    self.with_callback(|this, mut callback| {
+      (callback)(event.userify(), &this.window_target, control_flow);
+      this.will_exit |= *control_flow == ControlFlow::Exit;
+      if this.will_exit {
+        *control_flow = ControlFlow::Exit;
+      }
+    });
+  }
 
-    fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
-        self.with_callback(|this, mut callback| {
-            let mut will_exit = this.will_exit;
-            for event in this.window_target.p.receiver.try_iter() {
-                (callback)(Event::UserEvent(event), &this.window_target, control_flow);
-                will_exit |= *control_flow == ControlFlow::Exit;
-                if will_exit {
-                    *control_flow = ControlFlow::Exit;
-                }
-            }
-            this.will_exit = will_exit;
-        });
-    }
+  fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
+    self.with_callback(|this, mut callback| {
+      let mut will_exit = this.will_exit;
+      for event in this.window_target.p.receiver.try_iter() {
+        (callback)(Event::UserEvent(event), &this.window_target, control_flow);
+        will_exit |= *control_flow == ControlFlow::Exit;
+        if will_exit {
+          *control_flow = ControlFlow::Exit;
+        }
+      }
+      this.will_exit = will_exit;
+    });
+  }
 }
 
 #[derive(Default)]
 struct Handler {
-    ready: AtomicBool,
-    in_callback: AtomicBool,
-    dialog_is_closing: AtomicBool,
-    control_flow: Mutex<ControlFlow>,
-    control_flow_prev: Mutex<ControlFlow>,
-    start_time: Mutex<Option<Instant>>,
-    callback: Mutex<Option<Box<dyn EventHandler>>>,
-    pending_events: Mutex<VecDeque<EventWrapper>>,
-    pending_redraw: Mutex<Vec<WindowId>>,
-    waker: Mutex<EventLoopWaker>,
+  ready: AtomicBool,
+  in_callback: AtomicBool,
+  dialog_is_closing: AtomicBool,
+  control_flow: Mutex<ControlFlow>,
+  control_flow_prev: Mutex<ControlFlow>,
+  start_time: Mutex<Option<Instant>>,
+  callback: Mutex<Option<Box<dyn EventHandler>>>,
+  pending_events: Mutex<VecDeque<EventWrapper>>,
+  pending_redraw: Mutex<Vec<WindowId>>,
+  waker: Mutex<EventLoopWaker>,
 }
 
 unsafe impl Send for Handler {}
 unsafe impl Sync for Handler {}
 
 impl Handler {
-    fn events(&self) -> MutexGuard<'_, VecDeque<EventWrapper>> {
-        self.pending_events.lock().unwrap()
-    }
+  fn events(&self) -> MutexGuard<'_, VecDeque<EventWrapper>> {
+    self.pending_events.lock().unwrap()
+  }
 
-    fn redraw<'a>(&'a self) -> MutexGuard<'a, Vec<WindowId>> {
-        self.pending_redraw.lock().unwrap()
-    }
+  fn redraw<'a>(&'a self) -> MutexGuard<'a, Vec<WindowId>> {
+    self.pending_redraw.lock().unwrap()
+  }
 
-    fn waker(&self) -> MutexGuard<'_, EventLoopWaker> {
-        self.waker.lock().unwrap()
-    }
+  fn waker(&self) -> MutexGuard<'_, EventLoopWaker> {
+    self.waker.lock().unwrap()
+  }
 
-    fn is_ready(&self) -> bool {
-        self.ready.load(Ordering::Acquire)
-    }
+  fn is_ready(&self) -> bool {
+    self.ready.load(Ordering::Acquire)
+  }
 
-    fn set_ready(&self) {
-        self.ready.store(true, Ordering::Release);
-    }
+  fn set_ready(&self) {
+    self.ready.store(true, Ordering::Release);
+  }
 
-    fn should_exit(&self) -> bool {
-        *self.control_flow.lock().unwrap() == ControlFlow::Exit
-    }
+  fn should_exit(&self) -> bool {
+    *self.control_flow.lock().unwrap() == ControlFlow::Exit
+  }
 
-    fn get_control_flow_and_update_prev(&self) -> ControlFlow {
-        let control_flow = self.control_flow.lock().unwrap();
-        *self.control_flow_prev.lock().unwrap() = *control_flow;
-        *control_flow
-    }
+  fn get_control_flow_and_update_prev(&self) -> ControlFlow {
+    let control_flow = self.control_flow.lock().unwrap();
+    *self.control_flow_prev.lock().unwrap() = *control_flow;
+    *control_flow
+  }
 
-    fn get_old_and_new_control_flow(&self) -> (ControlFlow, ControlFlow) {
-        let old = *self.control_flow_prev.lock().unwrap();
-        let new = *self.control_flow.lock().unwrap();
-        (old, new)
-    }
+  fn get_old_and_new_control_flow(&self) -> (ControlFlow, ControlFlow) {
+    let old = *self.control_flow_prev.lock().unwrap();
+    let new = *self.control_flow.lock().unwrap();
+    (old, new)
+  }
 
-    fn get_start_time(&self) -> Option<Instant> {
-        *self.start_time.lock().unwrap()
-    }
+  fn get_start_time(&self) -> Option<Instant> {
+    *self.start_time.lock().unwrap()
+  }
 
-    fn update_start_time(&self) {
-        *self.start_time.lock().unwrap() = Some(Instant::now());
-    }
+  fn update_start_time(&self) {
+    *self.start_time.lock().unwrap() = Some(Instant::now());
+  }
 
-    fn take_events(&self) -> VecDeque<EventWrapper> {
-        mem::replace(&mut *self.events(), Default::default())
-    }
+  fn take_events(&self) -> VecDeque<EventWrapper> {
+    mem::replace(&mut *self.events(), Default::default())
+  }
 
-    fn should_redraw(&self) -> Vec<WindowId> {
-        mem::replace(&mut *self.redraw(), Default::default())
-    }
+  fn should_redraw(&self) -> Vec<WindowId> {
+    mem::replace(&mut *self.redraw(), Default::default())
+  }
 
-    fn get_in_callback(&self) -> bool {
-        self.in_callback.load(Ordering::Acquire)
-    }
+  fn get_in_callback(&self) -> bool {
+    self.in_callback.load(Ordering::Acquire)
+  }
 
-    fn set_in_callback(&self, in_callback: bool) {
-        self.in_callback.store(in_callback, Ordering::Release);
-    }
+  fn set_in_callback(&self, in_callback: bool) {
+    self.in_callback.store(in_callback, Ordering::Release);
+  }
 
-    fn handle_nonuser_event(&self, wrapper: EventWrapper) {
-        if let Some(ref mut callback) = *self.callback.lock().unwrap() {
-            match wrapper {
-                EventWrapper::StaticEvent(event) => {
-                    callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap())
-                }
-                EventWrapper::EventProxy(proxy) => self.handle_proxy(proxy, callback),
-            }
+  fn handle_nonuser_event(&self, wrapper: EventWrapper) {
+    if let Some(ref mut callback) = *self.callback.lock().unwrap() {
+      match wrapper {
+        EventWrapper::StaticEvent(event) => {
+          callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap())
         }
+        EventWrapper::EventProxy(proxy) => self.handle_proxy(proxy, callback),
+      }
     }
+  }
 
-    fn handle_user_events(&self) {
-        if let Some(ref mut callback) = *self.callback.lock().unwrap() {
-            callback.handle_user_events(&mut *self.control_flow.lock().unwrap());
-        }
+  fn handle_user_events(&self) {
+    if let Some(ref mut callback) = *self.callback.lock().unwrap() {
+      callback.handle_user_events(&mut *self.control_flow.lock().unwrap());
     }
+  }
 
-    fn handle_scale_factor_changed_event(
-        &self,
-        callback: &mut Box<dyn EventHandler + 'static>,
-        ns_window: IdRef,
-        suggested_size: LogicalSize<f64>,
-        scale_factor: f64,
-    ) {
-        let mut size = suggested_size.to_physical(scale_factor);
-        let new_inner_size = &mut size;
-        let event = Event::WindowEvent {
-            window_id: WindowId(get_window_id(*ns_window)),
-            event: WindowEvent::ScaleFactorChanged {
-                scale_factor,
-                new_inner_size,
-            },
-        };
+  fn handle_scale_factor_changed_event(
+    &self,
+    callback: &mut Box<dyn EventHandler + 'static>,
+    ns_window: IdRef,
+    suggested_size: LogicalSize<f64>,
+    scale_factor: f64,
+  ) {
+    let mut size = suggested_size.to_physical(scale_factor);
+    let new_inner_size = &mut size;
+    let event = Event::WindowEvent {
+      window_id: WindowId(get_window_id(*ns_window)),
+      event: WindowEvent::ScaleFactorChanged {
+        scale_factor,
+        new_inner_size,
+      },
+    };
 
-        callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap());
+    callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap());
 
-        let physical_size = *new_inner_size;
-        let logical_size = physical_size.to_logical(scale_factor);
-        let size = NSSize::new(logical_size.width, logical_size.height);
-        unsafe { NSWindow::setContentSize_(*ns_window, size) };
-    }
-
-    fn handle_proxy(&self, proxy: EventProxy, callback: &mut Box<dyn EventHandler + 'static>) {
-        match proxy {
-            EventProxy::DpiChangedProxy {
-                ns_window,
-                suggested_size,
-                scale_factor,
-            } => self.handle_scale_factor_changed_event(
-                callback,
-                ns_window,
-                suggested_size,
-                scale_factor,
-            ),
-        }
+    let physical_size = *new_inner_size;
+    let logical_size = physical_size.to_logical(scale_factor);
+    let size = NSSize::new(logical_size.width, logical_size.height);
+    unsafe { NSWindow::setContentSize_(*ns_window, size) };
+  }
+
+  fn handle_proxy(&self, proxy: EventProxy, callback: &mut Box<dyn EventHandler + 'static>) {
+    match proxy {
+      EventProxy::DpiChangedProxy {
+        ns_window,
+        suggested_size,
+        scale_factor,
+      } => {
+        self.handle_scale_factor_changed_event(callback, ns_window, suggested_size, scale_factor)
+      }
     }
+  }
 }
 
 pub static INTERRUPT_EVENT_LOOP_EXIT: AtomicBool = AtomicBool::new(false);
@@ -261,180 +259,175 @@ pub static INTERRUPT_EVENT_LOOP_EXIT: AtomicBool = AtomicBool::new(false);
 pub enum AppState {}
 
 impl AppState {
-    pub fn set_callback<T>(
-        callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
-        window_target: Rc<RootWindowTarget<T>>,
-    ) {
-        *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
-            callback,
-            will_exit: false,
-            window_target,
-        }));
-    }
+  pub fn set_callback<T>(
+    callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+    window_target: Rc<RootWindowTarget<T>>,
+  ) {
+    *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
+      callback,
+      will_exit: false,
+      window_target,
+    }));
+  }
 
-    pub fn exit() {
-        HANDLER.set_in_callback(true);
-        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::LoopDestroyed));
-        HANDLER.set_in_callback(false);
-        HANDLER.callback.lock().unwrap().take();
-    }
+  pub fn exit() {
+    HANDLER.set_in_callback(true);
+    HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::LoopDestroyed));
+    HANDLER.set_in_callback(false);
+    HANDLER.callback.lock().unwrap().take();
+  }
 
-    pub fn launched(app_delegate: &Object) {
-        apply_activation_policy(app_delegate);
-        unsafe {
-            let ns_app = NSApp();
-            window_activation_hack(ns_app);
-            // TODO: Consider allowing the user to specify they don't want their application activated
-            ns_app.activateIgnoringOtherApps_(YES);
-        };
-        HANDLER.set_ready();
-        HANDLER.waker().start();
-        let create_default_menu = unsafe { get_aux_state_mut(app_delegate).create_default_menu };
-        if create_default_menu {
-            // The menubar initialization should be before the `NewEvents` event, to allow
-            // overriding of the default menu even if it's created
-            menu::initialize();
+  pub fn launched(app_delegate: &Object) {
+    apply_activation_policy(app_delegate);
+    unsafe {
+      let ns_app = NSApp();
+      window_activation_hack(ns_app);
+      // TODO: Consider allowing the user to specify they don't want their application activated
+      ns_app.activateIgnoringOtherApps_(YES);
+    };
+    HANDLER.set_ready();
+    HANDLER.waker().start();
+    let create_default_menu = unsafe { get_aux_state_mut(app_delegate).create_default_menu };
+    if create_default_menu {
+      // The menubar initialization should be before the `NewEvents` event, to allow
+      // overriding of the default menu even if it's created
+      menu::initialize();
+    }
+    HANDLER.set_in_callback(true);
+    HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(
+      StartCause::Init,
+    )));
+    HANDLER.set_in_callback(false);
+  }
+
+  pub fn wakeup(panic_info: Weak<PanicInfo>) {
+    let panic_info = panic_info
+      .upgrade()
+      .expect("The panic info must exist here. This failure indicates a developer error.");
+    if panic_info.is_panicking() || !HANDLER.is_ready() {
+      return;
+    }
+    let start = HANDLER.get_start_time().unwrap();
+    let cause = match HANDLER.get_control_flow_and_update_prev() {
+      ControlFlow::Poll => StartCause::Poll,
+      ControlFlow::Wait => StartCause::WaitCancelled {
+        start,
+        requested_resume: None,
+      },
+      ControlFlow::WaitUntil(requested_resume) => {
+        if Instant::now() >= requested_resume {
+          StartCause::ResumeTimeReached {
+            start,
+            requested_resume,
+          }
+        } else {
+          StartCause::WaitCancelled {
+            start,
+            requested_resume: Some(requested_resume),
+          }
         }
-        HANDLER.set_in_callback(true);
-        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(
-            StartCause::Init,
-        )));
-        HANDLER.set_in_callback(false);
-    }
+      }
+      ControlFlow::Exit => StartCause::Poll, //panic!("unexpected `ControlFlow::Exit`"),
+    };
+    HANDLER.set_in_callback(true);
+    HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(cause)));
+    HANDLER.set_in_callback(false);
+  }
 
-    pub fn wakeup(panic_info: Weak<PanicInfo>) {
-        let panic_info = panic_info
-            .upgrade()
-            .expect("The panic info must exist here. This failure indicates a developer error.");
-        if panic_info.is_panicking() || !HANDLER.is_ready() {
-            return;
-        }
-        let start = HANDLER.get_start_time().unwrap();
-        let cause = match HANDLER.get_control_flow_and_update_prev() {
-            ControlFlow::Poll => StartCause::Poll,
-            ControlFlow::Wait => StartCause::WaitCancelled {
-                start,
-                requested_resume: None,
-            },
-            ControlFlow::WaitUntil(requested_resume) => {
-                if Instant::now() >= requested_resume {
-                    StartCause::ResumeTimeReached {
-                        start,
-                        requested_resume,
-                    }
-                } else {
-                    StartCause::WaitCancelled {
-                        start,
-                        requested_resume: Some(requested_resume),
-                    }
-                }
-            }
-            ControlFlow::Exit => StartCause::Poll, //panic!("unexpected `ControlFlow::Exit`"),
-        };
-        HANDLER.set_in_callback(true);
-        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(cause)));
-        HANDLER.set_in_callback(false);
+  // This is called from multiple threads at present
+  pub fn queue_redraw(window_id: WindowId) {
+    let mut pending_redraw = HANDLER.redraw();
+    if !pending_redraw.contains(&window_id) {
+      pending_redraw.push(window_id);
     }
-
-    // This is called from multiple threads at present
-    pub fn queue_redraw(window_id: WindowId) {
-        let mut pending_redraw = HANDLER.redraw();
-        if !pending_redraw.contains(&window_id) {
-            pending_redraw.push(window_id);
-        }
-        unsafe {
-            let rl = CFRunLoopGetMain();
-            CFRunLoopWakeUp(rl);
-        }
+    unsafe {
+      let rl = CFRunLoopGetMain();
+      CFRunLoopWakeUp(rl);
     }
+  }
 
-    pub fn handle_redraw(window_id: WindowId) {
+  pub fn handle_redraw(window_id: WindowId) {
+    HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
+  }
+
+  pub fn queue_event(wrapper: EventWrapper) {
+    if !unsafe { msg_send![class!(NSThread), isMainThread] } {
+      panic!("Event queued from different thread: {:#?}", wrapper);
+    }
+    HANDLER.events().push_back(wrapper);
+  }
+
+  pub fn queue_events(mut wrappers: VecDeque<EventWrapper>) {
+    if !unsafe { msg_send![class!(NSThread), isMainThread] } {
+      panic!("Events queued from different thread: {:#?}", wrappers);
+    }
+    HANDLER.events().append(&mut wrappers);
+  }
+
+  pub fn cleared(panic_info: Weak<PanicInfo>) {
+    let panic_info = panic_info
+      .upgrade()
+      .expect("The panic info must exist here. This failure indicates a developer error.");
+    if panic_info.is_panicking() || !HANDLER.is_ready() {
+      return;
+    }
+    if !HANDLER.get_in_callback() {
+      HANDLER.set_in_callback(true);
+      HANDLER.handle_user_events();
+      for event in HANDLER.take_events() {
+        HANDLER.handle_nonuser_event(event);
+      }
+      HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
+      for window_id in HANDLER.should_redraw() {
         HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
+      }
+      HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
+      HANDLER.set_in_callback(false);
     }
+    if HANDLER.should_exit() {
+      unsafe {
+        let app: id = NSApp();
+        let windows: id = msg_send![app, windows];
+        let window_count: usize = msg_send![windows, count];
 
-    pub fn queue_event(wrapper: EventWrapper) {
-        if !unsafe { msg_send![class!(NSThread), isMainThread] } {
-            panic!("Event queued from different thread: {:#?}", wrapper);
+        let dialog_open = if window_count > 1 {
+          let dialog: id = msg_send![windows, lastObject];
+          let is_main_window: bool = msg_send![dialog, isMainWindow];
+          msg_send![dialog, isVisible] && !is_main_window
+        } else {
+          false
+        };
+
+        let dialog_is_closing = HANDLER.dialog_is_closing.load(Ordering::SeqCst);
+        let pool = NSAutoreleasePool::new(nil);
+        if !INTERRUPT_EVENT_LOOP_EXIT.load(Ordering::SeqCst) && !dialog_open && !dialog_is_closing {
+          let () = msg_send![app, stop: nil];
+          // To stop event loop immediately, we need to post some event here.
+          post_dummy_event(app);
         }
-        HANDLER.events().push_back(wrapper);
+        pool.drain();
+
+        if window_count > 0 {
+          let window: id = msg_send![windows, objectAtIndex:0];
+          let window_has_focus = msg_send![window, isKeyWindow];
+          if !dialog_open && window_has_focus && dialog_is_closing {
+            HANDLER.dialog_is_closing.store(false, Ordering::SeqCst);
+          }
+          if dialog_open {
+            HANDLER.dialog_is_closing.store(true, Ordering::SeqCst);
+          }
+        }
+      };
     }
-
-    pub fn queue_events(mut wrappers: VecDeque<EventWrapper>) {
-        if !unsafe { msg_send![class!(NSThread), isMainThread] } {
-            panic!("Events queued from different thread: {:#?}", wrappers);
-        }
-        HANDLER.events().append(&mut wrappers);
-    }
-
-    pub fn cleared(panic_info: Weak<PanicInfo>) {
-        let panic_info = panic_info
-            .upgrade()
-            .expect("The panic info must exist here. This failure indicates a developer error.");
-        if panic_info.is_panicking() || !HANDLER.is_ready() {
-            return;
-        }
-        if !HANDLER.get_in_callback() {
-            HANDLER.set_in_callback(true);
-            HANDLER.handle_user_events();
-            for event in HANDLER.take_events() {
-                HANDLER.handle_nonuser_event(event);
-            }
-            HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
-            for window_id in HANDLER.should_redraw() {
-                HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(
-                    window_id,
-                )));
-            }
-            HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
-            HANDLER.set_in_callback(false);
-        }
-        if HANDLER.should_exit() {
-            unsafe {
-                let app: id = NSApp();
-                let windows: id = msg_send![app, windows];
-                let window_count: usize = msg_send![windows, count];
-
-                let dialog_open = if window_count > 1 {
-                    let dialog: id = msg_send![windows, lastObject];
-                    let is_main_window: bool = msg_send![dialog, isMainWindow];
-                    msg_send![dialog, isVisible] && !is_main_window
-                } else {
-                    false
-                };
-
-                let dialog_is_closing = HANDLER.dialog_is_closing.load(Ordering::SeqCst);
-                let pool = NSAutoreleasePool::new(nil);
-                if !INTERRUPT_EVENT_LOOP_EXIT.load(Ordering::SeqCst)
-                    && !dialog_open
-                    && !dialog_is_closing
-                {
-                    let () = msg_send![app, stop: nil];
-                    // To stop event loop immediately, we need to post some event here.
-                    post_dummy_event(app);
-                }
-                pool.drain();
-
-                if window_count > 0 {
-                    let window: id = msg_send![windows, objectAtIndex:0];
-                    let window_has_focus = msg_send![window, isKeyWindow];
-                    if !dialog_open && window_has_focus && dialog_is_closing {
-                        HANDLER.dialog_is_closing.store(false, Ordering::SeqCst);
-                    }
-                    if dialog_open {
-                        HANDLER.dialog_is_closing.store(true, Ordering::SeqCst);
-                    }
-                }
-            };
-        }
-        HANDLER.update_start_time();
-        match HANDLER.get_old_and_new_control_flow() {
-            (ControlFlow::Exit, _) | (_, ControlFlow::Exit) => (),
-            (old, new) if old == new => (),
-            (_, ControlFlow::Wait) => HANDLER.waker().stop(),
-            (_, ControlFlow::WaitUntil(instant)) => HANDLER.waker().start_at(instant),
-            (_, ControlFlow::Poll) => HANDLER.waker().start(),
-        }
+    HANDLER.update_start_time();
+    match HANDLER.get_old_and_new_control_flow() {
+      (ControlFlow::Exit, _) | (_, ControlFlow::Exit) => (),
+      (old, new) if old == new => (),
+      (_, ControlFlow::Wait) => HANDLER.waker().stop(),
+      (_, ControlFlow::WaitUntil(instant)) => HANDLER.waker().start_at(instant),
+      (_, ControlFlow::Poll) => HANDLER.waker().start(),
     }
+  }
 }
 
 /// A hack to make activation of multiple windows work when creating them before
@@ -446,39 +439,39 @@ impl AppState {
 /// If this becomes too bothersome to maintain, it can probably be removed
 /// without too much damage.
 unsafe fn window_activation_hack(ns_app: id) {
-    // Get the application's windows
-    // TODO: Proper ordering of the windows
-    let ns_windows: id = msg_send![ns_app, windows];
-    let ns_enumerator: id = msg_send![ns_windows, objectEnumerator];
-    loop {
-        // Enumerate over the windows
-        let ns_window: id = msg_send![ns_enumerator, nextObject];
-        if ns_window == nil {
-            break;
-        }
-        // And call `makeKeyAndOrderFront` if it was called on the window in `UnownedWindow::new`
-        // This way we preserve the user's desired initial visiblity status
-        // TODO: Also filter on the type/"level" of the window, and maybe other things?
-        if ns_window.isVisible() == YES {
-            trace!("Activating visible window");
-            ns_window.makeKeyAndOrderFront_(nil);
-        } else {
-            trace!("Skipping activating invisible window");
-        }
+  // Get the application's windows
+  // TODO: Proper ordering of the windows
+  let ns_windows: id = msg_send![ns_app, windows];
+  let ns_enumerator: id = msg_send![ns_windows, objectEnumerator];
+  loop {
+    // Enumerate over the windows
+    let ns_window: id = msg_send![ns_enumerator, nextObject];
+    if ns_window == nil {
+      break;
     }
+    // And call `makeKeyAndOrderFront` if it was called on the window in `UnownedWindow::new`
+    // This way we preserve the user's desired initial visiblity status
+    // TODO: Also filter on the type/"level" of the window, and maybe other things?
+    if ns_window.isVisible() == YES {
+      trace!("Activating visible window");
+      ns_window.makeKeyAndOrderFront_(nil);
+    } else {
+      trace!("Skipping activating invisible window");
+    }
+  }
 }
 fn apply_activation_policy(app_delegate: &Object) {
-    unsafe {
-        use cocoa::appkit::NSApplicationActivationPolicy::*;
-        let ns_app = NSApp();
-        // We need to delay setting the activation policy and activating the app
-        // until `applicationDidFinishLaunching` has been called. Otherwise the
-        // menu bar won't be interactable.
-        let act_pol = get_aux_state_mut(app_delegate).activation_policy;
-        ns_app.setActivationPolicy_(match act_pol {
-            ActivationPolicy::Regular => NSApplicationActivationPolicyRegular,
-            ActivationPolicy::Accessory => NSApplicationActivationPolicyAccessory,
-            ActivationPolicy::Prohibited => NSApplicationActivationPolicyProhibited,
-        });
-    }
+  unsafe {
+    use cocoa::appkit::NSApplicationActivationPolicy::*;
+    let ns_app = NSApp();
+    // We need to delay setting the activation policy and activating the app
+    // until `applicationDidFinishLaunching` has been called. Otherwise the
+    // menu bar won't be interactable.
+    let act_pol = get_aux_state_mut(app_delegate).activation_policy;
+    ns_app.setActivationPolicy_(match act_pol {
+      ActivationPolicy::Regular => NSApplicationActivationPolicyRegular,
+      ActivationPolicy::Accessory => NSApplicationActivationPolicyAccessory,
+      ActivationPolicy::Prohibited => NSApplicationActivationPolicyProhibited,
+    });
+  }
 }

src/platform_impl/macos/event.rs

@@ -1,304 +1,304 @@
 use std::os::raw::c_ushort;
 
 use cocoa::{
-    appkit::{NSEvent, NSEventModifierFlags},
-    base::id,
+  appkit::{NSEvent, NSEventModifierFlags},
+  base::id,
 };
 
 use crate::{
-    dpi::LogicalSize,
-    event::{ElementState, Event, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent},
-    platform_impl::platform::{
-        util::{IdRef, Never},
-        DEVICE_ID,
-    },
+  dpi::LogicalSize,
+  event::{ElementState, Event, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent},
+  platform_impl::platform::{
+    util::{IdRef, Never},
+    DEVICE_ID,
+  },
 };
 
 #[derive(Debug)]
 pub enum EventWrapper {
-    StaticEvent(Event<'static, Never>),
-    EventProxy(EventProxy),
+  StaticEvent(Event<'static, Never>),
+  EventProxy(EventProxy),
 }
 
 #[derive(Debug, PartialEq)]
 pub enum EventProxy {
-    DpiChangedProxy {
-        ns_window: IdRef,
-        suggested_size: LogicalSize<f64>,
-        scale_factor: f64,
-    },
+  DpiChangedProxy {
+    ns_window: IdRef,
+    suggested_size: LogicalSize<f64>,
+    scale_factor: f64,
+  },
 }
 
 pub fn char_to_keycode(c: char) -> Option<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' => VirtualKeyCode::A,
-        'b' | 'B' => VirtualKeyCode::B,
-        'c' | 'C' => VirtualKeyCode::C,
-        'd' | 'D' => VirtualKeyCode::D,
-        'e' | 'E' => VirtualKeyCode::E,
-        'f' | 'F' => VirtualKeyCode::F,
-        'g' | 'G' => VirtualKeyCode::G,
-        'h' | 'H' => VirtualKeyCode::H,
-        'i' | 'I' => VirtualKeyCode::I,
-        'j' | 'J' => VirtualKeyCode::J,
-        'k' | 'K' => VirtualKeyCode::K,
-        'l' | 'L' => VirtualKeyCode::L,
-        'm' | 'M' => VirtualKeyCode::M,
-        'n' | 'N' => VirtualKeyCode::N,
-        'o' | 'O' => VirtualKeyCode::O,
-        'p' | 'P' => VirtualKeyCode::P,
-        'q' | 'Q' => VirtualKeyCode::Q,
-        'r' | 'R' => VirtualKeyCode::R,
-        's' | 'S' => VirtualKeyCode::S,
-        't' | 'T' => VirtualKeyCode::T,
-        'u' | 'U' => VirtualKeyCode::U,
-        'v' | 'V' => VirtualKeyCode::V,
-        'w' | 'W' => VirtualKeyCode::W,
-        'x' | 'X' => VirtualKeyCode::X,
-        'y' | 'Y' => VirtualKeyCode::Y,
-        'z' | 'Z' => VirtualKeyCode::Z,
-        '1' | '!' => VirtualKeyCode::Key1,
-        '2' | '@' => VirtualKeyCode::Key2,
-        '3' | '#' => VirtualKeyCode::Key3,
-        '4' | '$' => VirtualKeyCode::Key4,
-        '5' | '%' => VirtualKeyCode::Key5,
-        '6' | '^' => VirtualKeyCode::Key6,
-        '7' | '&' => VirtualKeyCode::Key7,
-        '8' | '*' => VirtualKeyCode::Key8,
-        '9' | '(' => VirtualKeyCode::Key9,
-        '0' | ')' => VirtualKeyCode::Key0,
-        '=' | '+' => VirtualKeyCode::Equals,
-        '-' | '_' => VirtualKeyCode::Minus,
-        ']' | '}' => VirtualKeyCode::RBracket,
-        '[' | '{' => VirtualKeyCode::LBracket,
-        '\'' | '"' => VirtualKeyCode::Apostrophe,
-        ';' | ':' => VirtualKeyCode::Semicolon,
-        '\\' | '|' => VirtualKeyCode::Backslash,
-        ',' | '<' => VirtualKeyCode::Comma,
-        '/' | '?' => VirtualKeyCode::Slash,
-        '.' | '>' => VirtualKeyCode::Period,
-        '`' | '~' => VirtualKeyCode::Grave,
-        _ => return None,
-    })
+  // 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' => VirtualKeyCode::A,
+    'b' | 'B' => VirtualKeyCode::B,
+    'c' | 'C' => VirtualKeyCode::C,
+    'd' | 'D' => VirtualKeyCode::D,
+    'e' | 'E' => VirtualKeyCode::E,
+    'f' | 'F' => VirtualKeyCode::F,
+    'g' | 'G' => VirtualKeyCode::G,
+    'h' | 'H' => VirtualKeyCode::H,
+    'i' | 'I' => VirtualKeyCode::I,
+    'j' | 'J' => VirtualKeyCode::J,
+    'k' | 'K' => VirtualKeyCode::K,
+    'l' | 'L' => VirtualKeyCode::L,
+    'm' | 'M' => VirtualKeyCode::M,
+    'n' | 'N' => VirtualKeyCode::N,
+    'o' | 'O' => VirtualKeyCode::O,
+    'p' | 'P' => VirtualKeyCode::P,
+    'q' | 'Q' => VirtualKeyCode::Q,
+    'r' | 'R' => VirtualKeyCode::R,
+    's' | 'S' => VirtualKeyCode::S,
+    't' | 'T' => VirtualKeyCode::T,
+    'u' | 'U' => VirtualKeyCode::U,
+    'v' | 'V' => VirtualKeyCode::V,
+    'w' | 'W' => VirtualKeyCode::W,
+    'x' | 'X' => VirtualKeyCode::X,
+    'y' | 'Y' => VirtualKeyCode::Y,
+    'z' | 'Z' => VirtualKeyCode::Z,
+    '1' | '!' => VirtualKeyCode::Key1,
+    '2' | '@' => VirtualKeyCode::Key2,
+    '3' | '#' => VirtualKeyCode::Key3,
+    '4' | '$' => VirtualKeyCode::Key4,
+    '5' | '%' => VirtualKeyCode::Key5,
+    '6' | '^' => VirtualKeyCode::Key6,
+    '7' | '&' => VirtualKeyCode::Key7,
+    '8' | '*' => VirtualKeyCode::Key8,
+    '9' | '(' => VirtualKeyCode::Key9,
+    '0' | ')' => VirtualKeyCode::Key0,
+    '=' | '+' => VirtualKeyCode::Equals,
+    '-' | '_' => VirtualKeyCode::Minus,
+    ']' | '}' => VirtualKeyCode::RBracket,
+    '[' | '{' => VirtualKeyCode::LBracket,
+    '\'' | '"' => VirtualKeyCode::Apostrophe,
+    ';' | ':' => VirtualKeyCode::Semicolon,
+    '\\' | '|' => VirtualKeyCode::Backslash,
+    ',' | '<' => VirtualKeyCode::Comma,
+    '/' | '?' => VirtualKeyCode::Slash,
+    '.' | '>' => VirtualKeyCode::Period,
+    '`' | '~' => VirtualKeyCode::Grave,
+    _ => return None,
+  })
 }
 
 pub fn scancode_to_keycode(scancode: c_ushort) -> Option<VirtualKeyCode> {
-    Some(match scancode {
-        0x00 => VirtualKeyCode::A,
-        0x01 => VirtualKeyCode::S,
-        0x02 => VirtualKeyCode::D,
-        0x03 => VirtualKeyCode::F,
-        0x04 => VirtualKeyCode::H,
-        0x05 => VirtualKeyCode::G,
-        0x06 => VirtualKeyCode::Z,
-        0x07 => VirtualKeyCode::X,
-        0x08 => VirtualKeyCode::C,
-        0x09 => VirtualKeyCode::V,
-        //0x0a => World 1,
-        0x0b => VirtualKeyCode::B,
-        0x0c => VirtualKeyCode::Q,
-        0x0d => VirtualKeyCode::W,
-        0x0e => VirtualKeyCode::E,
-        0x0f => VirtualKeyCode::R,
-        0x10 => VirtualKeyCode::Y,
-        0x11 => VirtualKeyCode::T,
-        0x12 => VirtualKeyCode::Key1,
-        0x13 => VirtualKeyCode::Key2,
-        0x14 => VirtualKeyCode::Key3,
-        0x15 => VirtualKeyCode::Key4,
-        0x16 => VirtualKeyCode::Key6,
-        0x17 => VirtualKeyCode::Key5,
-        0x18 => VirtualKeyCode::Equals,
-        0x19 => VirtualKeyCode::Key9,
-        0x1a => VirtualKeyCode::Key7,
-        0x1b => VirtualKeyCode::Minus,
-        0x1c => VirtualKeyCode::Key8,
-        0x1d => VirtualKeyCode::Key0,
-        0x1e => VirtualKeyCode::RBracket,
-        0x1f => VirtualKeyCode::O,
-        0x20 => VirtualKeyCode::U,
-        0x21 => VirtualKeyCode::LBracket,
-        0x22 => VirtualKeyCode::I,
-        0x23 => VirtualKeyCode::P,
-        0x24 => VirtualKeyCode::Return,
-        0x25 => VirtualKeyCode::L,
-        0x26 => VirtualKeyCode::J,
-        0x27 => VirtualKeyCode::Apostrophe,
-        0x28 => VirtualKeyCode::K,
-        0x29 => VirtualKeyCode::Semicolon,
-        0x2a => VirtualKeyCode::Backslash,
-        0x2b => VirtualKeyCode::Comma,
-        0x2c => VirtualKeyCode::Slash,
-        0x2d => VirtualKeyCode::N,
-        0x2e => VirtualKeyCode::M,
-        0x2f => VirtualKeyCode::Period,
-        0x30 => VirtualKeyCode::Tab,
-        0x31 => VirtualKeyCode::Space,
-        0x32 => VirtualKeyCode::Grave,
-        0x33 => VirtualKeyCode::Back,
-        //0x34 => unkown,
-        0x35 => VirtualKeyCode::Escape,
-        0x36 => VirtualKeyCode::RWin,
-        0x37 => VirtualKeyCode::LWin,
-        0x38 => VirtualKeyCode::LShift,
-        //0x39 => Caps lock,
-        0x3a => VirtualKeyCode::LAlt,
-        0x3b => VirtualKeyCode::LControl,
-        0x3c => VirtualKeyCode::RShift,
-        0x3d => VirtualKeyCode::RAlt,
-        0x3e => VirtualKeyCode::RControl,
-        //0x3f => Fn key,
-        0x40 => VirtualKeyCode::F17,
-        0x41 => VirtualKeyCode::NumpadDecimal,
-        //0x42 -> unkown,
-        0x43 => VirtualKeyCode::NumpadMultiply,
-        //0x44 => unkown,
-        0x45 => VirtualKeyCode::NumpadAdd,
-        //0x46 => unkown,
-        0x47 => VirtualKeyCode::Numlock,
-        //0x48 => KeypadClear,
-        0x49 => VirtualKeyCode::VolumeUp,
-        0x4a => VirtualKeyCode::VolumeDown,
-        0x4b => VirtualKeyCode::NumpadDivide,
-        0x4c => VirtualKeyCode::NumpadEnter,
-        //0x4d => unkown,
-        0x4e => VirtualKeyCode::NumpadSubtract,
-        0x4f => VirtualKeyCode::F18,
-        0x50 => VirtualKeyCode::F19,
-        0x51 => VirtualKeyCode::NumpadEquals,
-        0x52 => VirtualKeyCode::Numpad0,
-        0x53 => VirtualKeyCode::Numpad1,
-        0x54 => VirtualKeyCode::Numpad2,
-        0x55 => VirtualKeyCode::Numpad3,
-        0x56 => VirtualKeyCode::Numpad4,
-        0x57 => VirtualKeyCode::Numpad5,
-        0x58 => VirtualKeyCode::Numpad6,
-        0x59 => VirtualKeyCode::Numpad7,
-        0x5a => VirtualKeyCode::F20,
-        0x5b => VirtualKeyCode::Numpad8,
-        0x5c => VirtualKeyCode::Numpad9,
-        0x5d => VirtualKeyCode::Yen,
-        //0x5e => JIS Ro,
-        //0x5f => unkown,
-        0x60 => VirtualKeyCode::F5,
-        0x61 => VirtualKeyCode::F6,
-        0x62 => VirtualKeyCode::F7,
-        0x63 => VirtualKeyCode::F3,
-        0x64 => VirtualKeyCode::F8,
-        0x65 => VirtualKeyCode::F9,
-        //0x66 => JIS Eisuu (macOS),
-        0x67 => VirtualKeyCode::F11,
-        //0x68 => JIS Kanna (macOS),
-        0x69 => VirtualKeyCode::F13,
-        0x6a => VirtualKeyCode::F16,
-        0x6b => VirtualKeyCode::F14,
-        //0x6c => unkown,
-        0x6d => VirtualKeyCode::F10,
-        //0x6e => unkown,
-        0x6f => VirtualKeyCode::F12,
-        //0x70 => unkown,
-        0x71 => VirtualKeyCode::F15,
-        0x72 => VirtualKeyCode::Insert,
-        0x73 => VirtualKeyCode::Home,
-        0x74 => VirtualKeyCode::PageUp,
-        0x75 => VirtualKeyCode::Delete,
-        0x76 => VirtualKeyCode::F4,
-        0x77 => VirtualKeyCode::End,
-        0x78 => VirtualKeyCode::F2,
-        0x79 => VirtualKeyCode::PageDown,
-        0x7a => VirtualKeyCode::F1,
-        0x7b => VirtualKeyCode::Left,
-        0x7c => VirtualKeyCode::Right,
-        0x7d => VirtualKeyCode::Down,
-        0x7e => VirtualKeyCode::Up,
-        //0x7f =>  unkown,
-        0xa => VirtualKeyCode::Caret,
-        _ => return None,
-    })
+  Some(match scancode {
+    0x00 => VirtualKeyCode::A,
+    0x01 => VirtualKeyCode::S,
+    0x02 => VirtualKeyCode::D,
+    0x03 => VirtualKeyCode::F,
+    0x04 => VirtualKeyCode::H,
+    0x05 => VirtualKeyCode::G,
+    0x06 => VirtualKeyCode::Z,
+    0x07 => VirtualKeyCode::X,
+    0x08 => VirtualKeyCode::C,
+    0x09 => VirtualKeyCode::V,
+    //0x0a => World 1,
+    0x0b => VirtualKeyCode::B,
+    0x0c => VirtualKeyCode::Q,
+    0x0d => VirtualKeyCode::W,
+    0x0e => VirtualKeyCode::E,
+    0x0f => VirtualKeyCode::R,
+    0x10 => VirtualKeyCode::Y,
+    0x11 => VirtualKeyCode::T,
+    0x12 => VirtualKeyCode::Key1,
+    0x13 => VirtualKeyCode::Key2,
+    0x14 => VirtualKeyCode::Key3,
+    0x15 => VirtualKeyCode::Key4,
+    0x16 => VirtualKeyCode::Key6,
+    0x17 => VirtualKeyCode::Key5,
+    0x18 => VirtualKeyCode::Equals,
+    0x19 => VirtualKeyCode::Key9,
+    0x1a => VirtualKeyCode::Key7,
+    0x1b => VirtualKeyCode::Minus,
+    0x1c => VirtualKeyCode::Key8,
+    0x1d => VirtualKeyCode::Key0,
+    0x1e => VirtualKeyCode::RBracket,
+    0x1f => VirtualKeyCode::O,
+    0x20 => VirtualKeyCode::U,
+    0x21 => VirtualKeyCode::LBracket,
+    0x22 => VirtualKeyCode::I,
+    0x23 => VirtualKeyCode::P,
+    0x24 => VirtualKeyCode::Return,
+    0x25 => VirtualKeyCode::L,
+    0x26 => VirtualKeyCode::J,
+    0x27 => VirtualKeyCode::Apostrophe,
+    0x28 => VirtualKeyCode::K,
+    0x29 => VirtualKeyCode::Semicolon,
+    0x2a => VirtualKeyCode::Backslash,
+    0x2b => VirtualKeyCode::Comma,
+    0x2c => VirtualKeyCode::Slash,
+    0x2d => VirtualKeyCode::N,
+    0x2e => VirtualKeyCode::M,
+    0x2f => VirtualKeyCode::Period,
+    0x30 => VirtualKeyCode::Tab,
+    0x31 => VirtualKeyCode::Space,
+    0x32 => VirtualKeyCode::Grave,
+    0x33 => VirtualKeyCode::Back,
+    //0x34 => unkown,
+    0x35 => VirtualKeyCode::Escape,
+    0x36 => VirtualKeyCode::RWin,
+    0x37 => VirtualKeyCode::LWin,
+    0x38 => VirtualKeyCode::LShift,
+    //0x39 => Caps lock,
+    0x3a => VirtualKeyCode::LAlt,
+    0x3b => VirtualKeyCode::LControl,
+    0x3c => VirtualKeyCode::RShift,
+    0x3d => VirtualKeyCode::RAlt,
+    0x3e => VirtualKeyCode::RControl,
+    //0x3f => Fn key,
+    0x40 => VirtualKeyCode::F17,
+    0x41 => VirtualKeyCode::NumpadDecimal,
+    //0x42 -> unkown,
+    0x43 => VirtualKeyCode::NumpadMultiply,
+    //0x44 => unkown,
+    0x45 => VirtualKeyCode::NumpadAdd,
+    //0x46 => unkown,
+    0x47 => VirtualKeyCode::Numlock,
+    //0x48 => KeypadClear,
+    0x49 => VirtualKeyCode::VolumeUp,
+    0x4a => VirtualKeyCode::VolumeDown,
+    0x4b => VirtualKeyCode::NumpadDivide,
+    0x4c => VirtualKeyCode::NumpadEnter,
+    //0x4d => unkown,
+    0x4e => VirtualKeyCode::NumpadSubtract,
+    0x4f => VirtualKeyCode::F18,
+    0x50 => VirtualKeyCode::F19,
+    0x51 => VirtualKeyCode::NumpadEquals,
+    0x52 => VirtualKeyCode::Numpad0,
+    0x53 => VirtualKeyCode::Numpad1,
+    0x54 => VirtualKeyCode::Numpad2,
+    0x55 => VirtualKeyCode::Numpad3,
+    0x56 => VirtualKeyCode::Numpad4,
+    0x57 => VirtualKeyCode::Numpad5,
+    0x58 => VirtualKeyCode::Numpad6,
+    0x59 => VirtualKeyCode::Numpad7,
+    0x5a => VirtualKeyCode::F20,
+    0x5b => VirtualKeyCode::Numpad8,
+    0x5c => VirtualKeyCode::Numpad9,
+    0x5d => VirtualKeyCode::Yen,
+    //0x5e => JIS Ro,
+    //0x5f => unkown,
+    0x60 => VirtualKeyCode::F5,
+    0x61 => VirtualKeyCode::F6,
+    0x62 => VirtualKeyCode::F7,
+    0x63 => VirtualKeyCode::F3,
+    0x64 => VirtualKeyCode::F8,
+    0x65 => VirtualKeyCode::F9,
+    //0x66 => JIS Eisuu (macOS),
+    0x67 => VirtualKeyCode::F11,
+    //0x68 => JIS Kanna (macOS),
+    0x69 => VirtualKeyCode::F13,
+    0x6a => VirtualKeyCode::F16,
+    0x6b => VirtualKeyCode::F14,
+    //0x6c => unkown,
+    0x6d => VirtualKeyCode::F10,
+    //0x6e => unkown,
+    0x6f => VirtualKeyCode::F12,
+    //0x70 => unkown,
+    0x71 => VirtualKeyCode::F15,
+    0x72 => VirtualKeyCode::Insert,
+    0x73 => VirtualKeyCode::Home,
+    0x74 => VirtualKeyCode::PageUp,
+    0x75 => VirtualKeyCode::Delete,
+    0x76 => VirtualKeyCode::F4,
+    0x77 => VirtualKeyCode::End,
+    0x78 => VirtualKeyCode::F2,
+    0x79 => VirtualKeyCode::PageDown,
+    0x7a => VirtualKeyCode::F1,
+    0x7b => VirtualKeyCode::Left,
+    0x7c => VirtualKeyCode::Right,
+    0x7d => VirtualKeyCode::Down,
+    0x7e => VirtualKeyCode::Up,
+    //0x7f =>  unkown,
+    0xa => VirtualKeyCode::Caret,
+    _ => return None,
+  })
 }
 
 // While F1-F20 have scancodes we can match on, we have to check against UTF-16
 // constants for the rest.
 // https://developer.apple.com/documentation/appkit/1535851-function-key_unicodes?preferredLanguage=occ
 pub fn check_function_keys(string: &str) -> Option<VirtualKeyCode> {
-    if let Some(ch) = string.encode_utf16().next() {
-        return Some(match ch {
-            0xf718 => VirtualKeyCode::F21,
-            0xf719 => VirtualKeyCode::F22,
-            0xf71a => VirtualKeyCode::F23,
-            0xf71b => VirtualKeyCode::F24,
-            _ => return None,
-        });
-    }
+  if let Some(ch) = string.encode_utf16().next() {
+    return Some(match ch {
+      0xf718 => VirtualKeyCode::F21,
+      0xf719 => VirtualKeyCode::F22,
+      0xf71a => VirtualKeyCode::F23,
+      0xf71b => VirtualKeyCode::F24,
+      _ => return None,
+    });
+  }
 
-    None
+  None
 }
 
 pub fn event_mods(event: id) -> ModifiersState {
-    let flags = unsafe { NSEvent::modifierFlags(event) };
-    let mut m = ModifiersState::empty();
-    m.set(
-        ModifiersState::SHIFT,
-        flags.contains(NSEventModifierFlags::NSShiftKeyMask),
-    );
-    m.set(
-        ModifiersState::CTRL,
-        flags.contains(NSEventModifierFlags::NSControlKeyMask),
-    );
-    m.set(
-        ModifiersState::ALT,
-        flags.contains(NSEventModifierFlags::NSAlternateKeyMask),
-    );
-    m.set(
-        ModifiersState::LOGO,
-        flags.contains(NSEventModifierFlags::NSCommandKeyMask),
-    );
-    m
+  let flags = unsafe { NSEvent::modifierFlags(event) };
+  let mut m = ModifiersState::empty();
+  m.set(
+    ModifiersState::SHIFT,
+    flags.contains(NSEventModifierFlags::NSShiftKeyMask),
+  );
+  m.set(
+    ModifiersState::CTRL,
+    flags.contains(NSEventModifierFlags::NSControlKeyMask),
+  );
+  m.set(
+    ModifiersState::ALT,
+    flags.contains(NSEventModifierFlags::NSAlternateKeyMask),
+  );
+  m.set(
+    ModifiersState::LOGO,
+    flags.contains(NSEventModifierFlags::NSCommandKeyMask),
+  );
+  m
 }
 
 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] }
+  // 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] }
 }
 
 pub unsafe fn modifier_event(
-    ns_event: id,
-    keymask: NSEventModifierFlags,
-    was_key_pressed: bool,
+  ns_event: id,
+  keymask: NSEventModifierFlags,
+  was_key_pressed: bool,
 ) -> Option<WindowEvent<'static>> {
-    if !was_key_pressed && NSEvent::modifierFlags(ns_event).contains(keymask)
-        || was_key_pressed && !NSEvent::modifierFlags(ns_event).contains(keymask)
-    {
-        let state = if was_key_pressed {
-            ElementState::Released
-        } else {
-            ElementState::Pressed
-        };
-
-        let scancode = get_scancode(ns_event);
-        let virtual_keycode = scancode_to_keycode(scancode);
-        #[allow(deprecated)]
-        Some(WindowEvent::KeyboardInput {
-            device_id: DEVICE_ID,
-            input: KeyboardInput {
-                state,
-                scancode: scancode as _,
-                virtual_keycode,
-                modifiers: event_mods(ns_event),
-            },
-            is_synthetic: false,
-        })
+  if !was_key_pressed && NSEvent::modifierFlags(ns_event).contains(keymask)
+    || was_key_pressed && !NSEvent::modifierFlags(ns_event).contains(keymask)
+  {
+    let state = if was_key_pressed {
+      ElementState::Released
     } else {
-        None
-    }
+      ElementState::Pressed
+    };
+
+    let scancode = get_scancode(ns_event);
+    let virtual_keycode = scancode_to_keycode(scancode);
+    #[allow(deprecated)]
+    Some(WindowEvent::KeyboardInput {
+      device_id: DEVICE_ID,
+      input: KeyboardInput {
+        state,
+        scancode: scancode as _,
+        virtual_keycode,
+        modifiers: event_mods(ns_event),
+      },
+      is_synthetic: false,
+    })
+  } else {
+    None
+  }
 }

src/platform_impl/macos/event_loop.rs

@@ -1,41 +1,41 @@
 use std::{
-    any::Any,
-    cell::{Cell, RefCell},
-    collections::VecDeque,
-    marker::PhantomData,
-    mem,
-    os::raw::c_void,
-    panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe},
-    process, ptr,
-    rc::{Rc, Weak},
-    sync::mpsc,
+  any::Any,
+  cell::{Cell, RefCell},
+  collections::VecDeque,
+  marker::PhantomData,
+  mem,
+  os::raw::c_void,
+  panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe},
+  process, ptr,
+  rc::{Rc, Weak},
+  sync::mpsc,
 };
 
 use cocoa::{
-    appkit::{NSApp, NSEventType::NSApplicationDefined},
-    base::{id, nil, YES},
-    foundation::{NSAutoreleasePool, NSPoint},
+  appkit::{NSApp, NSEventType::NSApplicationDefined},
+  base::{id, nil, YES},
+  foundation::{NSAutoreleasePool, NSPoint},
 };
 
 use scopeguard::defer;
 
 use crate::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootWindowTarget},
-    monitor::MonitorHandle as RootMonitorHandle,
-    platform_impl::platform::{
-        app::APP_CLASS,
-        app_delegate::APP_DELEGATE_CLASS,
-        app_state::AppState,
-        monitor::{self, MonitorHandle},
-        observer::*,
-        util::IdRef,
-    },
+  event::Event,
+  event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootWindowTarget},
+  monitor::MonitorHandle as RootMonitorHandle,
+  platform_impl::platform::{
+    app::APP_CLASS,
+    app_delegate::APP_DELEGATE_CLASS,
+    app_state::AppState,
+    monitor::{self, MonitorHandle},
+    observer::*,
+    util::IdRef,
+  },
 };
 
 #[derive(Default)]
 pub struct PanicInfo {
-    inner: Cell<Option<Box<dyn Any + Send + 'static>>>,
+  inner: Cell<Option<Box<dyn Any + Send + 'static>>>,
 }
 
 // WARNING:
@@ -44,251 +44,251 @@ pub struct PanicInfo {
 impl UnwindSafe for PanicInfo {}
 impl RefUnwindSafe for PanicInfo {}
 impl PanicInfo {
-    pub fn is_panicking(&self) -> bool {
-        let inner = self.inner.take();
-        let result = inner.is_some();
-        self.inner.set(inner);
-        result
-    }
-    /// Overwrites the curret state if the current state is not panicking
-    pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
-        if !self.is_panicking() {
-            self.inner.set(Some(p));
-        }
-    }
-    pub fn take(&self) -> Option<Box<dyn Any + Send + 'static>> {
-        self.inner.take()
+  pub fn is_panicking(&self) -> bool {
+    let inner = self.inner.take();
+    let result = inner.is_some();
+    self.inner.set(inner);
+    result
+  }
+  /// Overwrites the curret state if the current state is not panicking
+  pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
+    if !self.is_panicking() {
+      self.inner.set(Some(p));
     }
+  }
+  pub fn take(&self) -> Option<Box<dyn Any + Send + 'static>> {
+    self.inner.take()
+  }
 }
 
 pub struct EventLoopWindowTarget<T: 'static> {
-    pub sender: mpsc::Sender<T>, // this is only here to be cloned elsewhere
-    pub receiver: mpsc::Receiver<T>,
+  pub sender: mpsc::Sender<T>, // this is only here to be cloned elsewhere
+  pub receiver: mpsc::Receiver<T>,
 }
 
 impl<T> Default for EventLoopWindowTarget<T> {
-    fn default() -> Self {
-        let (sender, receiver) = mpsc::channel();
-        EventLoopWindowTarget { sender, receiver }
-    }
+  fn default() -> Self {
+    let (sender, receiver) = mpsc::channel();
+    EventLoopWindowTarget { sender, receiver }
+  }
 }
 
 impl<T: 'static> EventLoopWindowTarget<T> {
-    #[inline]
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        monitor::available_monitors()
-    }
+  #[inline]
+  pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+    monitor::available_monitors()
+  }
 
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
-        let monitor = monitor::primary_monitor();
-        Some(RootMonitorHandle { inner: monitor })
-    }
+  #[inline]
+  pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    let monitor = monitor::primary_monitor();
+    Some(RootMonitorHandle { inner: monitor })
+  }
 }
 
 pub struct EventLoop<T: 'static> {
-    pub(crate) delegate: IdRef,
+  pub(crate) delegate: IdRef,
 
-    window_target: Rc<RootWindowTarget<T>>,
-    panic_info: Rc<PanicInfo>,
+  window_target: Rc<RootWindowTarget<T>>,
+  panic_info: Rc<PanicInfo>,
 
-    /// We make sure that the callback closure is dropped during a panic
-    /// by making the event loop own it.
-    ///
-    /// Every other reference should be a Weak reference which is only upgraded
-    /// into a strong reference in order to call the callback but then the
-    /// strong reference should be dropped as soon as possible.
-    _callback: Option<Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>>,
+  /// We make sure that the callback closure is dropped during a panic
+  /// by making the event loop own it.
+  ///
+  /// Every other reference should be a Weak reference which is only upgraded
+  /// into a strong reference in order to call the callback but then the
+  /// strong reference should be dropped as soon as possible.
+  _callback: Option<Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>>,
 }
 
 impl<T> EventLoop<T> {
-    pub fn new() -> Self {
-        let delegate = unsafe {
-            if !msg_send![class!(NSThread), isMainThread] {
-                panic!("On macOS, `EventLoop` must be created on the main thread!");
-            }
+  pub fn new() -> Self {
+    let delegate = unsafe {
+      if !msg_send![class!(NSThread), isMainThread] {
+        panic!("On macOS, `EventLoop` must be created on the main thread!");
+      }
 
-            // This must be done before `NSApp()` (equivalent to sending
-            // `sharedApplication`) is called anywhere else, or we'll end up
-            // with the wrong `NSApplication` class and the wrong thread could
-            // be marked as main.
-            let app: id = msg_send![APP_CLASS.0, sharedApplication];
+      // This must be done before `NSApp()` (equivalent to sending
+      // `sharedApplication`) is called anywhere else, or we'll end up
+      // with the wrong `NSApplication` class and the wrong thread could
+      // be marked as main.
+      let app: id = msg_send![APP_CLASS.0, sharedApplication];
 
-            let delegate = IdRef::new(msg_send![APP_DELEGATE_CLASS.0, new]);
-            let pool = NSAutoreleasePool::new(nil);
-            let _: () = msg_send![app, setDelegate:*delegate];
-            let _: () = msg_send![pool, drain];
-            delegate
-        };
-        let panic_info: Rc<PanicInfo> = Default::default();
-        setup_control_flow_observers(Rc::downgrade(&panic_info));
-        EventLoop {
-            delegate,
-            window_target: Rc::new(RootWindowTarget {
-                p: Default::default(),
-                _marker: PhantomData,
-            }),
-            panic_info,
-            _callback: None,
-        }
+      let delegate = IdRef::new(msg_send![APP_DELEGATE_CLASS.0, new]);
+      let pool = NSAutoreleasePool::new(nil);
+      let _: () = msg_send![app, setDelegate:*delegate];
+      let _: () = msg_send![pool, drain];
+      delegate
+    };
+    let panic_info: Rc<PanicInfo> = Default::default();
+    setup_control_flow_observers(Rc::downgrade(&panic_info));
+    EventLoop {
+      delegate,
+      window_target: Rc::new(RootWindowTarget {
+        p: Default::default(),
+        _marker: PhantomData,
+      }),
+      panic_info,
+      _callback: None,
     }
+  }
 
-    pub fn window_target(&self) -> &RootWindowTarget<T> {
-        &self.window_target
+  pub fn window_target(&self) -> &RootWindowTarget<T> {
+    &self.window_target
+  }
+
+  pub fn run<F>(mut self, callback: F) -> !
+  where
+    F: 'static + FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
+  {
+    self.run_return(callback);
+    process::exit(0);
+  }
+
+  pub fn run_return<F>(&mut self, callback: F)
+  where
+    F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
+  {
+    // This transmute is always safe, in case it was reached through `run`, since our
+    // lifetime will be already 'static. In other cases caller should ensure that all data
+    // they passed to callback will actually outlive it, some apps just can't move
+    // everything to event loop, so this is something that they should care about.
+    let callback = unsafe {
+      mem::transmute::<
+        Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+        Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+      >(Rc::new(RefCell::new(callback)))
+    };
+
+    self._callback = Some(Rc::clone(&callback));
+
+    unsafe {
+      let pool = NSAutoreleasePool::new(nil);
+      defer!(pool.drain());
+      let app = NSApp();
+      assert_ne!(app, nil);
+
+      // A bit of juggling with the callback references to make sure
+      // that `self.callback` is the only owner of the callback.
+      let weak_cb: Weak<_> = Rc::downgrade(&callback);
+      mem::drop(callback);
+
+      AppState::set_callback(weak_cb, Rc::clone(&self.window_target));
+      let () = msg_send![app, run];
+
+      if let Some(panic) = self.panic_info.take() {
+        resume_unwind(panic);
+      }
+      AppState::exit();
     }
+  }
 
-    pub fn run<F>(mut self, callback: F) -> !
-    where
-        F: 'static + FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
-    {
-        self.run_return(callback);
-        process::exit(0);
-    }
-
-    pub fn run_return<F>(&mut self, callback: F)
-    where
-        F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
-    {
-        // This transmute is always safe, in case it was reached through `run`, since our
-        // lifetime will be already 'static. In other cases caller should ensure that all data
-        // they passed to callback will actually outlive it, some apps just can't move
-        // everything to event loop, so this is something that they should care about.
-        let callback = unsafe {
-            mem::transmute::<
-                Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
-                Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
-            >(Rc::new(RefCell::new(callback)))
-        };
-
-        self._callback = Some(Rc::clone(&callback));
-
-        unsafe {
-            let pool = NSAutoreleasePool::new(nil);
-            defer!(pool.drain());
-            let app = NSApp();
-            assert_ne!(app, nil);
-
-            // A bit of juggling with the callback references to make sure
-            // that `self.callback` is the only owner of the callback.
-            let weak_cb: Weak<_> = Rc::downgrade(&callback);
-            mem::drop(callback);
-
-            AppState::set_callback(weak_cb, Rc::clone(&self.window_target));
-            let () = msg_send![app, run];
-
-            if let Some(panic) = self.panic_info.take() {
-                resume_unwind(panic);
-            }
-            AppState::exit();
-        }
-    }
-
-    pub fn create_proxy(&self) -> Proxy<T> {
-        Proxy::new(self.window_target.p.sender.clone())
-    }
+  pub fn create_proxy(&self) -> Proxy<T> {
+    Proxy::new(self.window_target.p.sender.clone())
+  }
 }
 
 #[inline]
 pub unsafe fn post_dummy_event(target: id) {
-    let event_class = class!(NSEvent);
-    let dummy_event: id = msg_send![
-        event_class,
-        otherEventWithType: NSApplicationDefined
-        location: NSPoint::new(0.0, 0.0)
-        modifierFlags: 0
-        timestamp: 0
-        windowNumber: 0
-        context: nil
-        subtype: 0
-        data1: 0
-        data2: 0
-    ];
-    let () = msg_send![target, postEvent: dummy_event atStart: YES];
+  let event_class = class!(NSEvent);
+  let dummy_event: id = msg_send![
+      event_class,
+      otherEventWithType: NSApplicationDefined
+      location: NSPoint::new(0.0, 0.0)
+      modifierFlags: 0
+      timestamp: 0
+      windowNumber: 0
+      context: nil
+      subtype: 0
+      data1: 0
+      data2: 0
+  ];
+  let () = msg_send![target, postEvent: dummy_event atStart: YES];
 }
 
 /// Catches panics that happen inside `f` and when a panic
 /// happens, stops the `sharedApplication`
 #[inline]
 pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
-    panic_info: Weak<PanicInfo>,
-    f: F,
+  panic_info: Weak<PanicInfo>,
+  f: F,
 ) -> Option<R> {
-    match catch_unwind(f) {
-        Ok(r) => Some(r),
-        Err(e) => {
-            // It's important that we set the panic before requesting a `stop`
-            // because some callback are still called during the `stop` message
-            // and we need to know in those callbacks if the application is currently
-            // panicking
-            {
-                let panic_info = panic_info.upgrade().unwrap();
-                panic_info.set_panic(e);
-            }
-            unsafe {
-                let app_class = class!(NSApplication);
-                let app: id = msg_send![app_class, sharedApplication];
-                let () = msg_send![app, stop: nil];
+  match catch_unwind(f) {
+    Ok(r) => Some(r),
+    Err(e) => {
+      // It's important that we set the panic before requesting a `stop`
+      // because some callback are still called during the `stop` message
+      // and we need to know in those callbacks if the application is currently
+      // panicking
+      {
+        let panic_info = panic_info.upgrade().unwrap();
+        panic_info.set_panic(e);
+      }
+      unsafe {
+        let app_class = class!(NSApplication);
+        let app: id = msg_send![app_class, sharedApplication];
+        let () = msg_send![app, stop: nil];
 
-                // Posting a dummy event to get `stop` to take effect immediately.
-                // See: https://stackoverflow.com/questions/48041279/stopping-the-nsapplication-main-event-loop/48064752#48064752
-                post_dummy_event(app);
-            }
-            None
-        }
+        // Posting a dummy event to get `stop` to take effect immediately.
+        // See: https://stackoverflow.com/questions/48041279/stopping-the-nsapplication-main-event-loop/48064752#48064752
+        post_dummy_event(app);
+      }
+      None
     }
+  }
 }
 
 pub struct Proxy<T> {
-    sender: mpsc::Sender<T>,
-    source: CFRunLoopSourceRef,
+  sender: mpsc::Sender<T>,
+  source: CFRunLoopSourceRef,
 }
 
 unsafe impl<T: Send> Send for Proxy<T> {}
 
 impl<T> Drop for Proxy<T> {
-    fn drop(&mut self) {
-        unsafe {
-            CFRelease(self.source as _);
-        }
+  fn drop(&mut self) {
+    unsafe {
+      CFRelease(self.source as _);
     }
+  }
 }
 
 impl<T> Clone for Proxy<T> {
-    fn clone(&self) -> Self {
-        Proxy::new(self.sender.clone())
-    }
+  fn clone(&self) -> Self {
+    Proxy::new(self.sender.clone())
+  }
 }
 
 impl<T> Proxy<T> {
-    fn new(sender: mpsc::Sender<T>) -> Self {
-        unsafe {
-            // just wake up the eventloop
-            extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
+  fn new(sender: mpsc::Sender<T>) -> Self {
+    unsafe {
+      // just wake up the eventloop
+      extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
 
-            // adding a Source to the main CFRunLoop lets us wake it up and
-            // process user events through the normal OS EventLoop mechanisms.
-            let rl = CFRunLoopGetMain();
-            let mut context: CFRunLoopSourceContext = mem::zeroed();
-            context.perform = Some(event_loop_proxy_handler);
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
-            CFRunLoopWakeUp(rl);
+      // adding a Source to the main CFRunLoop lets us wake it up and
+      // process user events through the normal OS EventLoop mechanisms.
+      let rl = CFRunLoopGetMain();
+      let mut context: CFRunLoopSourceContext = mem::zeroed();
+      context.perform = Some(event_loop_proxy_handler);
+      let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
+      CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+      CFRunLoopWakeUp(rl);
 
-            Proxy { sender, source }
-        }
+      Proxy { sender, source }
     }
+  }
 
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender
-            .send(event)
-            .map_err(|mpsc::SendError(x)| EventLoopClosed(x))?;
-        unsafe {
-            // let the main thread know there's a new event
-            CFRunLoopSourceSignal(self.source);
-            let rl = CFRunLoopGetMain();
-            CFRunLoopWakeUp(rl);
-        }
-        Ok(())
+  pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+    self
+      .sender
+      .send(event)
+      .map_err(|mpsc::SendError(x)| EventLoopClosed(x))?;
+    unsafe {
+      // let the main thread know there's a new event
+      CFRunLoopSourceSignal(self.source);
+      let rl = CFRunLoopGetMain();
+      CFRunLoopWakeUp(rl);
     }
+    Ok(())
+  }
 }

src/platform_impl/macos/ffi.rs

@@ -3,15 +3,15 @@
 #![allow(dead_code, non_snake_case, non_upper_case_globals)]
 
 use cocoa::{
-    base::id,
-    foundation::{NSInteger, NSUInteger},
+  base::id,
+  foundation::{NSInteger, NSUInteger},
 };
 use core_foundation::{
-    array::CFArrayRef, dictionary::CFDictionaryRef, string::CFStringRef, uuid::CFUUIDRef,
+  array::CFArrayRef, dictionary::CFDictionaryRef, string::CFStringRef, uuid::CFUUIDRef,
 };
 use core_graphics::{
-    base::CGError,
-    display::{CGDirectDisplayID, CGDisplayConfigRef},
+  base::CGError,
+  display::{CGDirectDisplayID, CGDisplayConfigRef},
 };
 use objc;
 
@@ -19,67 +19,67 @@ pub const NSNotFound: NSInteger = NSInteger::max_value();
 
 #[repr(C)]
 pub struct NSRange {
-    pub location: NSUInteger,
-    pub length: NSUInteger,
+  pub location: NSUInteger,
+  pub length: NSUInteger,
 }
 
 impl NSRange {
-    #[inline]
-    pub fn new(location: NSUInteger, length: NSUInteger) -> NSRange {
-        NSRange { location, length }
-    }
+  #[inline]
+  pub fn new(location: NSUInteger, length: NSUInteger) -> NSRange {
+    NSRange { location, length }
+  }
 }
 
 unsafe impl objc::Encode for NSRange {
-    fn encode() -> objc::Encoding {
-        let encoding = format!(
-            // TODO: Verify that this is correct
-            "{{NSRange={}{}}}",
-            NSUInteger::encode().as_str(),
-            NSUInteger::encode().as_str(),
-        );
-        unsafe { objc::Encoding::from_str(&encoding) }
-    }
+  fn encode() -> objc::Encoding {
+    let encoding = format!(
+      // TODO: Verify that this is correct
+      "{{NSRange={}{}}}",
+      NSUInteger::encode().as_str(),
+      NSUInteger::encode().as_str(),
+    );
+    unsafe { objc::Encoding::from_str(&encoding) }
+  }
 }
 
 pub trait NSMutableAttributedString: Sized {
-    unsafe fn alloc(_: Self) -> id {
-        msg_send![class!(NSMutableAttributedString), alloc]
-    }
+  unsafe fn alloc(_: Self) -> id {
+    msg_send![class!(NSMutableAttributedString), alloc]
+  }
 
-    unsafe fn init(self) -> id; // *mut NSMutableAttributedString
-    unsafe fn initWithString(self, string: id) -> id;
-    unsafe fn initWithAttributedString(self, string: id) -> id;
+  unsafe fn init(self) -> id; // *mut NSMutableAttributedString
+  unsafe fn initWithString(self, string: id) -> id;
+  unsafe fn initWithAttributedString(self, string: id) -> id;
 
-    unsafe fn string(self) -> id; // *mut NSString
-    unsafe fn mutableString(self) -> id; // *mut NSMutableString
-    unsafe fn length(self) -> NSUInteger;
+  unsafe fn string(self) -> id; // *mut NSString
+  unsafe fn mutableString(self) -> id; // *mut NSMutableString
+  unsafe fn length(self) -> NSUInteger;
 }
 
 impl NSMutableAttributedString for id {
-    unsafe fn init(self) -> id {
-        msg_send![self, init]
-    }
+  unsafe fn init(self) -> id {
+    msg_send![self, init]
+  }
 
-    unsafe fn initWithString(self, string: id) -> id {
-        msg_send![self, initWithString: string]
-    }
+  unsafe fn initWithString(self, string: id) -> id {
+    msg_send![self, initWithString: string]
+  }
 
-    unsafe fn initWithAttributedString(self, string: id) -> id {
-        msg_send![self, initWithAttributedString: string]
-    }
+  unsafe fn initWithAttributedString(self, string: id) -> id {
+    msg_send![self, initWithAttributedString: string]
+  }
 
-    unsafe fn string(self) -> id {
-        msg_send![self, string]
-    }
+  unsafe fn string(self) -> id {
+    msg_send![self, string]
+  }
 
-    unsafe fn mutableString(self) -> id {
-        msg_send![self, mutableString]
-    }
+  unsafe fn mutableString(self) -> id {
+    msg_send![self, mutableString]
+  }
 
-    unsafe fn length(self) -> NSUInteger {
-        msg_send![self, length]
-    }
+  unsafe fn length(self) -> NSUInteger {
+    msg_send![self, length]
+  }
 }
 
 pub const kCGBaseWindowLevelKey: NSInteger = 0;
@@ -106,14 +106,14 @@ pub const kCGNumberOfWindowLevelKeys: NSInteger = 20;
 
 #[derive(Debug, Clone, Copy)]
 pub enum NSWindowLevel {
-    NSNormalWindowLevel = kCGBaseWindowLevelKey as _,
-    NSFloatingWindowLevel = kCGFloatingWindowLevelKey as _,
-    NSTornOffMenuWindowLevel = kCGTornOffMenuWindowLevelKey as _,
-    NSModalPanelWindowLevel = kCGModalPanelWindowLevelKey as _,
-    NSMainMenuWindowLevel = kCGMainMenuWindowLevelKey as _,
-    NSStatusWindowLevel = kCGStatusWindowLevelKey as _,
-    NSPopUpMenuWindowLevel = kCGPopUpMenuWindowLevelKey as _,
-    NSScreenSaverWindowLevel = kCGScreenSaverWindowLevelKey as _,
+  NSNormalWindowLevel = kCGBaseWindowLevelKey as _,
+  NSFloatingWindowLevel = kCGFloatingWindowLevelKey as _,
+  NSTornOffMenuWindowLevel = kCGTornOffMenuWindowLevelKey as _,
+  NSModalPanelWindowLevel = kCGModalPanelWindowLevelKey as _,
+  NSMainMenuWindowLevel = kCGMainMenuWindowLevelKey as _,
+  NSStatusWindowLevel = kCGStatusWindowLevelKey as _,
+  NSPopUpMenuWindowLevel = kCGPopUpMenuWindowLevelKey as _,
+  NSScreenSaverWindowLevel = kCGScreenSaverWindowLevelKey as _,
 }
 
 pub type CGDisplayFadeInterval = f32;
@@ -162,59 +162,59 @@ pub type CGWindowLevel = i32;
 pub type CGDisplayModeRef = *mut libc::c_void;
 
 #[cfg_attr(
-    not(use_colorsync_cgdisplaycreateuuidfromdisplayid),
-    link(name = "CoreGraphics", kind = "framework")
+  not(use_colorsync_cgdisplaycreateuuidfromdisplayid),
+  link(name = "CoreGraphics", kind = "framework")
 )]
 #[cfg_attr(
-    use_colorsync_cgdisplaycreateuuidfromdisplayid,
-    link(name = "ColorSync", kind = "framework")
+  use_colorsync_cgdisplaycreateuuidfromdisplayid,
+  link(name = "ColorSync", kind = "framework")
 )]
 extern "C" {
-    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
+  pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
 }
 
 #[link(name = "CoreGraphics", kind = "framework")]
 extern "C" {
-    pub fn CGRestorePermanentDisplayConfiguration();
-    pub fn CGDisplayCapture(display: CGDirectDisplayID) -> CGError;
-    pub fn CGDisplayRelease(display: CGDirectDisplayID) -> CGError;
-    pub fn CGConfigureDisplayFadeEffect(
-        config: CGDisplayConfigRef,
-        fadeOutSeconds: CGDisplayFadeInterval,
-        fadeInSeconds: CGDisplayFadeInterval,
-        fadeRed: f32,
-        fadeGreen: f32,
-        fadeBlue: f32,
-    ) -> CGError;
-    pub fn CGAcquireDisplayFadeReservation(
-        seconds: CGDisplayReservationInterval,
-        token: *mut CGDisplayFadeReservationToken,
-    ) -> CGError;
-    pub fn CGDisplayFade(
-        token: CGDisplayFadeReservationToken,
-        duration: CGDisplayFadeInterval,
-        startBlend: CGDisplayBlendFraction,
-        endBlend: CGDisplayBlendFraction,
-        redBlend: f32,
-        greenBlend: f32,
-        blueBlend: f32,
-        synchronous: Boolean,
-    ) -> CGError;
-    pub fn CGReleaseDisplayFadeReservation(token: CGDisplayFadeReservationToken) -> CGError;
-    pub fn CGShieldingWindowLevel() -> CGWindowLevel;
-    pub fn CGDisplaySetDisplayMode(
-        display: CGDirectDisplayID,
-        mode: CGDisplayModeRef,
-        options: CFDictionaryRef,
-    ) -> CGError;
-    pub fn CGDisplayCopyAllDisplayModes(
-        display: CGDirectDisplayID,
-        options: CFDictionaryRef,
-    ) -> CFArrayRef;
-    pub fn CGDisplayModeGetPixelWidth(mode: CGDisplayModeRef) -> usize;
-    pub fn CGDisplayModeGetPixelHeight(mode: CGDisplayModeRef) -> usize;
-    pub fn CGDisplayModeGetRefreshRate(mode: CGDisplayModeRef) -> f64;
-    pub fn CGDisplayModeCopyPixelEncoding(mode: CGDisplayModeRef) -> CFStringRef;
-    pub fn CGDisplayModeRetain(mode: CGDisplayModeRef);
-    pub fn CGDisplayModeRelease(mode: CGDisplayModeRef);
+  pub fn CGRestorePermanentDisplayConfiguration();
+  pub fn CGDisplayCapture(display: CGDirectDisplayID) -> CGError;
+  pub fn CGDisplayRelease(display: CGDirectDisplayID) -> CGError;
+  pub fn CGConfigureDisplayFadeEffect(
+    config: CGDisplayConfigRef,
+    fadeOutSeconds: CGDisplayFadeInterval,
+    fadeInSeconds: CGDisplayFadeInterval,
+    fadeRed: f32,
+    fadeGreen: f32,
+    fadeBlue: f32,
+  ) -> CGError;
+  pub fn CGAcquireDisplayFadeReservation(
+    seconds: CGDisplayReservationInterval,
+    token: *mut CGDisplayFadeReservationToken,
+  ) -> CGError;
+  pub fn CGDisplayFade(
+    token: CGDisplayFadeReservationToken,
+    duration: CGDisplayFadeInterval,
+    startBlend: CGDisplayBlendFraction,
+    endBlend: CGDisplayBlendFraction,
+    redBlend: f32,
+    greenBlend: f32,
+    blueBlend: f32,
+    synchronous: Boolean,
+  ) -> CGError;
+  pub fn CGReleaseDisplayFadeReservation(token: CGDisplayFadeReservationToken) -> CGError;
+  pub fn CGShieldingWindowLevel() -> CGWindowLevel;
+  pub fn CGDisplaySetDisplayMode(
+    display: CGDirectDisplayID,
+    mode: CGDisplayModeRef,
+    options: CFDictionaryRef,
+  ) -> CGError;
+  pub fn CGDisplayCopyAllDisplayModes(
+    display: CGDirectDisplayID,
+    options: CFDictionaryRef,
+  ) -> CFArrayRef;
+  pub fn CGDisplayModeGetPixelWidth(mode: CGDisplayModeRef) -> usize;
+  pub fn CGDisplayModeGetPixelHeight(mode: CGDisplayModeRef) -> usize;
+  pub fn CGDisplayModeGetRefreshRate(mode: CGDisplayModeRef) -> f64;
+  pub fn CGDisplayModeCopyPixelEncoding(mode: CGDisplayModeRef) -> CFStringRef;
+  pub fn CGDisplayModeRetain(mode: CGDisplayModeRef);
+  pub fn CGDisplayModeRelease(mode: CGDisplayModeRef);
 }

src/platform_impl/macos/menu.rs

@@ -2,113 +2,112 @@ use cocoa::appkit::{NSApp, NSApplication, NSEventModifierFlags, NSMenu, NSMenuIt
 use cocoa::base::{nil, selector};
 use cocoa::foundation::{NSAutoreleasePool, NSProcessInfo, NSString};
 use objc::{
-    rc::autoreleasepool,
-    runtime::{Object, Sel},
+  rc::autoreleasepool,
+  runtime::{Object, Sel},
 };
 
 struct KeyEquivalent<'a> {
-    key: &'a str,
-    masks: Option<NSEventModifierFlags>,
+  key: &'a str,
+  masks: Option<NSEventModifierFlags>,
 }
 
 pub fn initialize() {
-    autoreleasepool(|| unsafe {
-        let menubar = NSMenu::new(nil).autorelease();
-        let app_menu_item = NSMenuItem::new(nil).autorelease();
-        menubar.addItem_(app_menu_item);
-        let app = NSApp();
-        app.setMainMenu_(menubar);
+  autoreleasepool(|| unsafe {
+    let menubar = NSMenu::new(nil).autorelease();
+    let app_menu_item = NSMenuItem::new(nil).autorelease();
+    menubar.addItem_(app_menu_item);
+    let app = NSApp();
+    app.setMainMenu_(menubar);
 
-        let app_menu = NSMenu::new(nil);
-        let process_name = NSProcessInfo::processInfo(nil).processName();
+    let app_menu = NSMenu::new(nil);
+    let process_name = NSProcessInfo::processInfo(nil).processName();
 
-        // About menu item
-        let about_item_prefix = NSString::alloc(nil).init_str("About ");
-        let about_item_title = about_item_prefix.stringByAppendingString_(process_name);
-        let about_item = menu_item(
-            about_item_title,
-            selector("orderFrontStandardAboutPanel:"),
-            None,
-        );
+    // About menu item
+    let about_item_prefix = NSString::alloc(nil).init_str("About ");
+    let about_item_title = about_item_prefix.stringByAppendingString_(process_name);
+    let about_item = menu_item(
+      about_item_title,
+      selector("orderFrontStandardAboutPanel:"),
+      None,
+    );
 
-        // Seperator menu item
-        let sep_first = NSMenuItem::separatorItem(nil);
+    // Seperator menu item
+    let sep_first = NSMenuItem::separatorItem(nil);
 
-        // Hide application menu item
-        let hide_item_prefix = NSString::alloc(nil).init_str("Hide ");
-        let hide_item_title = hide_item_prefix.stringByAppendingString_(process_name);
-        let hide_item = menu_item(
-            hide_item_title,
-            selector("hide:"),
-            Some(KeyEquivalent {
-                key: "h",
-                masks: None,
-            }),
-        );
+    // Hide application menu item
+    let hide_item_prefix = NSString::alloc(nil).init_str("Hide ");
+    let hide_item_title = hide_item_prefix.stringByAppendingString_(process_name);
+    let hide_item = menu_item(
+      hide_item_title,
+      selector("hide:"),
+      Some(KeyEquivalent {
+        key: "h",
+        masks: None,
+      }),
+    );
 
-        // Hide other applications menu item
-        let hide_others_item_title = NSString::alloc(nil).init_str("Hide Others");
-        let hide_others_item = menu_item(
-            hide_others_item_title,
-            selector("hideOtherApplications:"),
-            Some(KeyEquivalent {
-                key: "h",
-                masks: Some(
-                    NSEventModifierFlags::NSAlternateKeyMask
-                        | NSEventModifierFlags::NSCommandKeyMask,
-                ),
-            }),
-        );
+    // Hide other applications menu item
+    let hide_others_item_title = NSString::alloc(nil).init_str("Hide Others");
+    let hide_others_item = menu_item(
+      hide_others_item_title,
+      selector("hideOtherApplications:"),
+      Some(KeyEquivalent {
+        key: "h",
+        masks: Some(
+          NSEventModifierFlags::NSAlternateKeyMask | NSEventModifierFlags::NSCommandKeyMask,
+        ),
+      }),
+    );
 
-        // Show applications menu item
-        let show_all_item_title = NSString::alloc(nil).init_str("Show All");
-        let show_all_item = menu_item(
-            show_all_item_title,
-            selector("unhideAllApplications:"),
-            None,
-        );
+    // Show applications menu item
+    let show_all_item_title = NSString::alloc(nil).init_str("Show All");
+    let show_all_item = menu_item(
+      show_all_item_title,
+      selector("unhideAllApplications:"),
+      None,
+    );
 
-        // Seperator menu item
-        let sep = NSMenuItem::separatorItem(nil);
+    // Seperator menu item
+    let sep = NSMenuItem::separatorItem(nil);
 
-        // Quit application menu item
-        let quit_item_prefix = NSString::alloc(nil).init_str("Quit ");
-        let quit_item_title = quit_item_prefix.stringByAppendingString_(process_name);
-        let quit_item = menu_item(
-            quit_item_title,
-            selector("terminate:"),
-            Some(KeyEquivalent {
-                key: "q",
-                masks: None,
-            }),
-        );
+    // Quit application menu item
+    let quit_item_prefix = NSString::alloc(nil).init_str("Quit ");
+    let quit_item_title = quit_item_prefix.stringByAppendingString_(process_name);
+    let quit_item = menu_item(
+      quit_item_title,
+      selector("terminate:"),
+      Some(KeyEquivalent {
+        key: "q",
+        masks: None,
+      }),
+    );
 
-        app_menu.addItem_(about_item);
-        app_menu.addItem_(sep_first);
-        app_menu.addItem_(hide_item);
-        app_menu.addItem_(hide_others_item);
-        app_menu.addItem_(show_all_item);
-        app_menu.addItem_(sep);
-        app_menu.addItem_(quit_item);
-        app_menu_item.setSubmenu_(app_menu);
-    });
+    app_menu.addItem_(about_item);
+    app_menu.addItem_(sep_first);
+    app_menu.addItem_(hide_item);
+    app_menu.addItem_(hide_others_item);
+    app_menu.addItem_(show_all_item);
+    app_menu.addItem_(sep);
+    app_menu.addItem_(quit_item);
+    app_menu_item.setSubmenu_(app_menu);
+  });
 }
 
 fn menu_item(
-    title: *mut Object,
-    selector: Sel,
-    key_equivalent: Option<KeyEquivalent<'_>>,
+  title: *mut Object,
+  selector: Sel,
+  key_equivalent: Option<KeyEquivalent<'_>>,
 ) -> *mut Object {
-    unsafe {
-        let (key, masks) = match key_equivalent {
-            Some(ke) => (NSString::alloc(nil).init_str(ke.key), ke.masks),
-            None => (NSString::alloc(nil).init_str(""), None),
-        };
-        let item = NSMenuItem::alloc(nil).initWithTitle_action_keyEquivalent_(title, selector, key);
-        if let Some(masks) = masks {
-            item.setKeyEquivalentModifierMask_(masks)
-        }
-
-        item
+  unsafe {
+    let (key, masks) = match key_equivalent {
+      Some(ke) => (NSString::alloc(nil).init_str(ke.key), ke.masks),
+      None => (NSString::alloc(nil).init_str(""), None),
+    };
+    let item = NSMenuItem::alloc(nil).initWithTitle_action_keyEquivalent_(title, selector, key);
+    if let Some(masks) = masks {
+      item.setKeyEquivalentModifierMask_(masks)
     }
+
+    item
+  }
 }

src/platform_impl/macos/mod.rs

@@ -17,13 +17,13 @@ mod window_delegate;
 use std::{fmt, ops::Deref, sync::Arc};
 
 pub use self::{
-    app_delegate::{get_aux_state_mut, AuxDelegateState},
-    event_loop::{EventLoop, EventLoopWindowTarget, Proxy as EventLoopProxy},
-    monitor::{MonitorHandle, VideoMode},
-    window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, UnownedWindow},
+  app_delegate::{get_aux_state_mut, AuxDelegateState},
+  event_loop::{EventLoop, EventLoopWindowTarget, Proxy as EventLoopProxy},
+  monitor::{MonitorHandle, VideoMode},
+  window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, UnownedWindow},
 };
 use crate::{
-    error::OsError as RootOsError, event::DeviceId as RootDeviceId, window::WindowAttributes,
+  error::OsError as RootOsError, event::DeviceId as RootDeviceId, window::WindowAttributes,
 };
 
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
@@ -32,53 +32,53 @@ pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub struct DeviceId;
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
-        DeviceId
-    }
+  pub unsafe fn dummy() -> Self {
+    DeviceId
+  }
 }
 
 // Constant device ID; to be removed when if backend is updated to report real device IDs.
 pub(crate) const DEVICE_ID: RootDeviceId = RootDeviceId(DeviceId);
 
 pub struct Window {
-    window: Arc<UnownedWindow>,
-    // We keep this around so that it doesn't get dropped until the window does.
-    _delegate: util::IdRef,
+  window: Arc<UnownedWindow>,
+  // We keep this around so that it doesn't get dropped until the window does.
+  _delegate: util::IdRef,
 }
 
 #[derive(Debug)]
 pub enum OsError {
-    CGError(core_graphics::base::CGError),
-    CreationError(&'static str),
+  CGError(core_graphics::base::CGError),
+  CreationError(&'static str),
 }
 
 unsafe impl Send for Window {}
 unsafe impl Sync for Window {}
 
 impl Deref for Window {
-    type Target = UnownedWindow;
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &*self.window
-    }
+  type Target = UnownedWindow;
+  #[inline]
+  fn deref(&self) -> &Self::Target {
+    &*self.window
+  }
 }
 
 impl Window {
-    pub fn new<T: 'static>(
-        _window_target: &EventLoopWindowTarget<T>,
-        attributes: WindowAttributes,
-        pl_attribs: PlatformSpecificWindowBuilderAttributes,
-    ) -> Result<Self, RootOsError> {
-        let (window, _delegate) = UnownedWindow::new(attributes, pl_attribs)?;
-        Ok(Window { window, _delegate })
-    }
+  pub fn new<T: 'static>(
+    _window_target: &EventLoopWindowTarget<T>,
+    attributes: WindowAttributes,
+    pl_attribs: PlatformSpecificWindowBuilderAttributes,
+  ) -> Result<Self, RootOsError> {
+    let (window, _delegate) = UnownedWindow::new(attributes, pl_attribs)?;
+    Ok(Window { window, _delegate })
+  }
 }
 
 impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            OsError::CGError(e) => f.pad(&format!("CGError {}", e)),
-            OsError::CreationError(e) => f.pad(e),
-        }
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      OsError::CGError(e) => f.pad(&format!("CGError {}", e)),
+      OsError::CreationError(e) => f.pad(e),
     }
+  }
 }

src/platform_impl/macos/monitor.rs

@@ -2,63 +2,63 @@ use std::{collections::VecDeque, fmt};
 
 use super::{ffi, util};
 use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+  dpi::{PhysicalPosition, PhysicalSize},
+  monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
 };
 use cocoa::{
-    appkit::NSScreen,
-    base::{id, nil},
-    foundation::NSUInteger,
+  appkit::NSScreen,
+  base::{id, nil},
+  foundation::NSUInteger,
 };
 use core_foundation::{
-    array::{CFArrayGetCount, CFArrayGetValueAtIndex},
-    base::{CFRelease, TCFType},
-    string::CFString,
+  array::{CFArrayGetCount, CFArrayGetValueAtIndex},
+  base::{CFRelease, TCFType},
+  string::CFString,
 };
 use core_graphics::display::{CGDirectDisplayID, CGDisplay, CGDisplayBounds};
 use core_video_sys::{
-    kCVReturnSuccess, kCVTimeIsIndefinite, CVDisplayLinkCreateWithCGDisplay,
-    CVDisplayLinkGetNominalOutputVideoRefreshPeriod, CVDisplayLinkRelease,
+  kCVReturnSuccess, kCVTimeIsIndefinite, CVDisplayLinkCreateWithCGDisplay,
+  CVDisplayLinkGetNominalOutputVideoRefreshPeriod, CVDisplayLinkRelease,
 };
 
 #[derive(Clone)]
 pub struct VideoMode {
-    pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate: u16,
-    pub(crate) monitor: MonitorHandle,
-    pub(crate) native_mode: NativeDisplayMode,
+  pub(crate) size: (u32, u32),
+  pub(crate) bit_depth: u16,
+  pub(crate) refresh_rate: u16,
+  pub(crate) monitor: MonitorHandle,
+  pub(crate) native_mode: NativeDisplayMode,
 }
 
 impl PartialEq for VideoMode {
-    fn eq(&self, other: &Self) -> bool {
-        self.size == other.size
-            && self.bit_depth == other.bit_depth
-            && self.refresh_rate == other.refresh_rate
-            && self.monitor == other.monitor
-    }
+  fn eq(&self, other: &Self) -> bool {
+    self.size == other.size
+      && self.bit_depth == other.bit_depth
+      && self.refresh_rate == other.refresh_rate
+      && self.monitor == other.monitor
+  }
 }
 
 impl Eq for VideoMode {}
 
 impl std::hash::Hash for VideoMode {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.size.hash(state);
-        self.bit_depth.hash(state);
-        self.refresh_rate.hash(state);
-        self.monitor.hash(state);
-    }
+  fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    self.size.hash(state);
+    self.bit_depth.hash(state);
+    self.refresh_rate.hash(state);
+    self.monitor.hash(state);
+  }
 }
 
 impl std::fmt::Debug for VideoMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("VideoMode")
-            .field("size", &self.size)
-            .field("bit_depth", &self.bit_depth)
-            .field("refresh_rate", &self.refresh_rate)
-            .field("monitor", &self.monitor)
-            .finish()
-    }
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("VideoMode")
+      .field("size", &self.size)
+      .field("bit_depth", &self.bit_depth)
+      .field("refresh_rate", &self.refresh_rate)
+      .field("monitor", &self.monitor)
+      .finish()
+  }
 }
 
 pub struct NativeDisplayMode(pub ffi::CGDisplayModeRef);
@@ -66,40 +66,40 @@ pub struct NativeDisplayMode(pub ffi::CGDisplayModeRef);
 unsafe impl Send for NativeDisplayMode {}
 
 impl Drop for NativeDisplayMode {
-    fn drop(&mut self) {
-        unsafe {
-            ffi::CGDisplayModeRelease(self.0);
-        }
+  fn drop(&mut self) {
+    unsafe {
+      ffi::CGDisplayModeRelease(self.0);
     }
+  }
 }
 
 impl Clone for NativeDisplayMode {
-    fn clone(&self) -> Self {
-        unsafe {
-            ffi::CGDisplayModeRetain(self.0);
-        }
-        NativeDisplayMode(self.0)
+  fn clone(&self) -> Self {
+    unsafe {
+      ffi::CGDisplayModeRetain(self.0);
     }
+    NativeDisplayMode(self.0)
+  }
 }
 
 impl VideoMode {
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.size.into()
-    }
+  pub fn size(&self) -> PhysicalSize<u32> {
+    self.size.into()
+  }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
-    }
+  pub fn bit_depth(&self) -> u16 {
+    self.bit_depth
+  }
 
-    pub fn refresh_rate(&self) -> u16 {
-        self.refresh_rate
-    }
+  pub fn refresh_rate(&self) -> u16 {
+    self.refresh_rate
+  }
 
-    pub fn monitor(&self) -> RootMonitorHandle {
-        RootMonitorHandle {
-            inner: self.monitor.clone(),
-        }
+  pub fn monitor(&self) -> RootMonitorHandle {
+    RootMonitorHandle {
+      inner: self.monitor.clone(),
     }
+  }
 }
 
 #[derive(Clone)]
@@ -109,214 +109,213 @@ pub struct MonitorHandle(CGDirectDisplayID);
 // for comparisons, but we can use `CGDisplayCreateUUIDFromDisplayID` to get an
 // unique identifier that persists even across system reboots
 impl PartialEq for MonitorHandle {
-    fn eq(&self, other: &Self) -> bool {
-        unsafe {
-            ffi::CGDisplayCreateUUIDFromDisplayID(self.0)
-                == ffi::CGDisplayCreateUUIDFromDisplayID(other.0)
-        }
+  fn eq(&self, other: &Self) -> bool {
+    unsafe {
+      ffi::CGDisplayCreateUUIDFromDisplayID(self.0)
+        == ffi::CGDisplayCreateUUIDFromDisplayID(other.0)
     }
+  }
 }
 
 impl Eq for MonitorHandle {}
 
 impl PartialOrd for MonitorHandle {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(&other))
-    }
+  fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    Some(self.cmp(&other))
+  }
 }
 
 impl Ord for MonitorHandle {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        unsafe {
-            ffi::CGDisplayCreateUUIDFromDisplayID(self.0)
-                .cmp(&ffi::CGDisplayCreateUUIDFromDisplayID(other.0))
-        }
+  fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    unsafe {
+      ffi::CGDisplayCreateUUIDFromDisplayID(self.0)
+        .cmp(&ffi::CGDisplayCreateUUIDFromDisplayID(other.0))
     }
+  }
 }
 
 impl std::hash::Hash for MonitorHandle {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        unsafe {
-            ffi::CGDisplayCreateUUIDFromDisplayID(self.0).hash(state);
-        }
+  fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    unsafe {
+      ffi::CGDisplayCreateUUIDFromDisplayID(self.0).hash(state);
     }
+  }
 }
 
 pub fn available_monitors() -> VecDeque<MonitorHandle> {
-    if let Ok(displays) = CGDisplay::active_displays() {
-        let mut monitors = VecDeque::with_capacity(displays.len());
-        for display in displays {
-            monitors.push_back(MonitorHandle(display));
-        }
-        monitors
-    } else {
-        VecDeque::with_capacity(0)
+  if let Ok(displays) = CGDisplay::active_displays() {
+    let mut monitors = VecDeque::with_capacity(displays.len());
+    for display in displays {
+      monitors.push_back(MonitorHandle(display));
     }
+    monitors
+  } else {
+    VecDeque::with_capacity(0)
+  }
 }
 
 pub fn primary_monitor() -> MonitorHandle {
-    MonitorHandle(CGDisplay::main().id)
+  MonitorHandle(CGDisplay::main().id)
 }
 
 impl fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO: Do this using the proper fmt API
-        #[derive(Debug)]
-        struct MonitorHandle {
-            name: Option<String>,
-            native_identifier: u32,
-            size: PhysicalSize<u32>,
-            position: PhysicalPosition<i32>,
-            scale_factor: f64,
-        }
-
-        let monitor_id_proxy = MonitorHandle {
-            name: self.name(),
-            native_identifier: self.native_identifier(),
-            size: self.size(),
-            position: self.position(),
-            scale_factor: self.scale_factor(),
-        };
-
-        monitor_id_proxy.fmt(f)
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    // TODO: Do this using the proper fmt API
+    #[derive(Debug)]
+    struct MonitorHandle {
+      name: Option<String>,
+      native_identifier: u32,
+      size: PhysicalSize<u32>,
+      position: PhysicalPosition<i32>,
+      scale_factor: f64,
     }
+
+    let monitor_id_proxy = MonitorHandle {
+      name: self.name(),
+      native_identifier: self.native_identifier(),
+      size: self.size(),
+      position: self.position(),
+      scale_factor: self.scale_factor(),
+    };
+
+    monitor_id_proxy.fmt(f)
+  }
 }
 
 impl MonitorHandle {
-    pub fn new(id: CGDirectDisplayID) -> Self {
-        MonitorHandle(id)
-    }
+  pub fn new(id: CGDirectDisplayID) -> Self {
+    MonitorHandle(id)
+  }
 
-    pub fn name(&self) -> Option<String> {
-        let MonitorHandle(display_id) = *self;
-        let screen_num = CGDisplay::new(display_id).model_number();
-        Some(format!("Monitor #{}", screen_num))
-    }
+  pub fn name(&self) -> Option<String> {
+    let MonitorHandle(display_id) = *self;
+    let screen_num = CGDisplay::new(display_id).model_number();
+    Some(format!("Monitor #{}", screen_num))
+  }
 
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        self.0
-    }
+  #[inline]
+  pub fn native_identifier(&self) -> u32 {
+    self.0
+  }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        let MonitorHandle(display_id) = *self;
-        let display = CGDisplay::new(display_id);
-        let height = display.pixels_high();
-        let width = display.pixels_wide();
-        PhysicalSize::from_logical::<_, f64>((width as f64, height as f64), self.scale_factor())
-    }
+  pub fn size(&self) -> PhysicalSize<u32> {
+    let MonitorHandle(display_id) = *self;
+    let display = CGDisplay::new(display_id);
+    let height = display.pixels_high();
+    let width = display.pixels_wide();
+    PhysicalSize::from_logical::<_, f64>((width as f64, height as f64), self.scale_factor())
+  }
 
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        let bounds = unsafe { CGDisplayBounds(self.native_identifier()) };
-        PhysicalPosition::from_logical::<_, f64>(
-            (bounds.origin.x as f64, bounds.origin.y as f64),
-            self.scale_factor(),
-        )
-    }
+  #[inline]
+  pub fn position(&self) -> PhysicalPosition<i32> {
+    let bounds = unsafe { CGDisplayBounds(self.native_identifier()) };
+    PhysicalPosition::from_logical::<_, f64>(
+      (bounds.origin.x as f64, bounds.origin.y as f64),
+      self.scale_factor(),
+    )
+  }
 
-    pub fn scale_factor(&self) -> f64 {
-        let screen = match self.ns_screen() {
-            Some(screen) => screen,
-            None => return 1.0, // default to 1.0 when we can't find the screen
-        };
-        unsafe { NSScreen::backingScaleFactor(screen) as f64 }
-    }
+  pub fn scale_factor(&self) -> f64 {
+    let screen = match self.ns_screen() {
+      Some(screen) => screen,
+      None => return 1.0, // default to 1.0 when we can't find the screen
+    };
+    unsafe { NSScreen::backingScaleFactor(screen) as f64 }
+  }
 
-    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
-        let cv_refresh_rate = unsafe {
-            let mut display_link = std::ptr::null_mut();
-            assert_eq!(
-                CVDisplayLinkCreateWithCGDisplay(self.0, &mut display_link),
-                kCVReturnSuccess
-            );
-            let time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(display_link);
-            CVDisplayLinkRelease(display_link);
+  pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
+    let cv_refresh_rate = unsafe {
+      let mut display_link = std::ptr::null_mut();
+      assert_eq!(
+        CVDisplayLinkCreateWithCGDisplay(self.0, &mut display_link),
+        kCVReturnSuccess
+      );
+      let time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(display_link);
+      CVDisplayLinkRelease(display_link);
 
-            // This value is indefinite if an invalid display link was specified
-            assert!(time.flags & kCVTimeIsIndefinite == 0);
+      // This value is indefinite if an invalid display link was specified
+      assert!(time.flags & kCVTimeIsIndefinite == 0);
 
-            time.timeScale as i64 / time.timeValue
+      time.timeScale as i64 / time.timeValue
+    };
+
+    let monitor = self.clone();
+
+    unsafe {
+      let modes = {
+        let array = ffi::CGDisplayCopyAllDisplayModes(self.0, std::ptr::null());
+        assert!(!array.is_null(), "failed to get list of display modes");
+        let array_count = CFArrayGetCount(array);
+        let modes: Vec<_> = (0..array_count)
+          .map(move |i| {
+            let mode = CFArrayGetValueAtIndex(array, i) as *mut _;
+            ffi::CGDisplayModeRetain(mode);
+            mode
+          })
+          .collect();
+        CFRelease(array as *const _);
+        modes
+      };
+
+      modes.into_iter().map(move |mode| {
+        let cg_refresh_rate = ffi::CGDisplayModeGetRefreshRate(mode).round() as i64;
+
+        // CGDisplayModeGetRefreshRate returns 0.0 for any display that
+        // isn't a CRT
+        let refresh_rate = if cg_refresh_rate > 0 {
+          cg_refresh_rate
+        } else {
+          cv_refresh_rate
         };
 
-        let monitor = self.clone();
+        let pixel_encoding =
+          CFString::wrap_under_create_rule(ffi::CGDisplayModeCopyPixelEncoding(mode)).to_string();
+        let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
+          32
+        } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
+          16
+        } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
+          30
+        } else {
+          unimplemented!()
+        };
 
-        unsafe {
-            let modes = {
-                let array = ffi::CGDisplayCopyAllDisplayModes(self.0, std::ptr::null());
-                assert!(!array.is_null(), "failed to get list of display modes");
-                let array_count = CFArrayGetCount(array);
-                let modes: Vec<_> = (0..array_count)
-                    .map(move |i| {
-                        let mode = CFArrayGetValueAtIndex(array, i) as *mut _;
-                        ffi::CGDisplayModeRetain(mode);
-                        mode
-                    })
-                    .collect();
-                CFRelease(array as *const _);
-                modes
-            };
+        let video_mode = VideoMode {
+          size: (
+            ffi::CGDisplayModeGetPixelWidth(mode) as u32,
+            ffi::CGDisplayModeGetPixelHeight(mode) as u32,
+          ),
+          refresh_rate: refresh_rate as u16,
+          bit_depth,
+          monitor: monitor.clone(),
+          native_mode: NativeDisplayMode(mode),
+        };
 
-            modes.into_iter().map(move |mode| {
-                let cg_refresh_rate = ffi::CGDisplayModeGetRefreshRate(mode).round() as i64;
-
-                // CGDisplayModeGetRefreshRate returns 0.0 for any display that
-                // isn't a CRT
-                let refresh_rate = if cg_refresh_rate > 0 {
-                    cg_refresh_rate
-                } else {
-                    cv_refresh_rate
-                };
-
-                let pixel_encoding =
-                    CFString::wrap_under_create_rule(ffi::CGDisplayModeCopyPixelEncoding(mode))
-                        .to_string();
-                let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
-                    32
-                } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
-                    16
-                } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
-                    30
-                } else {
-                    unimplemented!()
-                };
-
-                let video_mode = VideoMode {
-                    size: (
-                        ffi::CGDisplayModeGetPixelWidth(mode) as u32,
-                        ffi::CGDisplayModeGetPixelHeight(mode) as u32,
-                    ),
-                    refresh_rate: refresh_rate as u16,
-                    bit_depth,
-                    monitor: monitor.clone(),
-                    native_mode: NativeDisplayMode(mode),
-                };
-
-                RootVideoMode { video_mode }
-            })
-        }
+        RootVideoMode { video_mode }
+      })
     }
+  }
 
-    pub(crate) fn ns_screen(&self) -> Option<id> {
-        unsafe {
-            let uuid = ffi::CGDisplayCreateUUIDFromDisplayID(self.0);
-            let screens = NSScreen::screens(nil);
-            let count: NSUInteger = msg_send![screens, count];
-            let key = util::ns_string_id_ref("NSScreenNumber");
-            for i in 0..count {
-                let screen = msg_send![screens, objectAtIndex: i as NSUInteger];
-                let device_description = NSScreen::deviceDescription(screen);
-                let value: id = msg_send![device_description, objectForKey:*key];
-                if value != nil {
-                    let other_native_id: NSUInteger = msg_send![value, unsignedIntegerValue];
-                    let other_uuid =
-                        ffi::CGDisplayCreateUUIDFromDisplayID(other_native_id as CGDirectDisplayID);
-                    if uuid == other_uuid {
-                        return Some(screen);
-                    }
-                }
-            }
-            None
+  pub(crate) fn ns_screen(&self) -> Option<id> {
+    unsafe {
+      let uuid = ffi::CGDisplayCreateUUIDFromDisplayID(self.0);
+      let screens = NSScreen::screens(nil);
+      let count: NSUInteger = msg_send![screens, count];
+      let key = util::ns_string_id_ref("NSScreenNumber");
+      for i in 0..count {
+        let screen = msg_send![screens, objectAtIndex: i as NSUInteger];
+        let device_description = NSScreen::deviceDescription(screen);
+        let value: id = msg_send![device_description, objectForKey:*key];
+        if value != nil {
+          let other_native_id: NSUInteger = msg_send![value, unsignedIntegerValue];
+          let other_uuid =
+            ffi::CGDisplayCreateUUIDFromDisplayID(other_native_id as CGDirectDisplayID);
+          if uuid == other_uuid {
+            return Some(screen);
+          }
         }
+      }
+      None
     }
+  }
 }

src/platform_impl/macos/observer.rs

@@ -1,64 +1,64 @@
 use std::{
-    self,
-    os::raw::*,
-    panic::{AssertUnwindSafe, UnwindSafe},
-    ptr,
-    rc::Weak,
-    time::Instant,
+  self,
+  os::raw::*,
+  panic::{AssertUnwindSafe, UnwindSafe},
+  ptr,
+  rc::Weak,
+  time::Instant,
 };
 
 use crate::platform_impl::platform::{
-    app_state::AppState,
-    event_loop::{stop_app_on_panic, PanicInfo},
-    ffi,
+  app_state::AppState,
+  event_loop::{stop_app_on_panic, PanicInfo},
+  ffi,
 };
 
 #[link(name = "CoreFoundation", kind = "framework")]
 extern "C" {
-    pub static kCFRunLoopCommonModes: CFRunLoopMode;
+  pub static kCFRunLoopCommonModes: CFRunLoopMode;
 
-    pub fn CFRunLoopGetMain() -> CFRunLoopRef;
-    pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
+  pub fn CFRunLoopGetMain() -> CFRunLoopRef;
+  pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
 
-    pub fn CFRunLoopObserverCreate(
-        allocator: CFAllocatorRef,
-        activities: CFOptionFlags,
-        repeats: ffi::Boolean,
-        order: CFIndex,
-        callout: CFRunLoopObserverCallBack,
-        context: *mut CFRunLoopObserverContext,
-    ) -> CFRunLoopObserverRef;
-    pub fn CFRunLoopAddObserver(
-        rl: CFRunLoopRef,
-        observer: CFRunLoopObserverRef,
-        mode: CFRunLoopMode,
-    );
+  pub fn CFRunLoopObserverCreate(
+    allocator: CFAllocatorRef,
+    activities: CFOptionFlags,
+    repeats: ffi::Boolean,
+    order: CFIndex,
+    callout: CFRunLoopObserverCallBack,
+    context: *mut CFRunLoopObserverContext,
+  ) -> CFRunLoopObserverRef;
+  pub fn CFRunLoopAddObserver(
+    rl: CFRunLoopRef,
+    observer: CFRunLoopObserverRef,
+    mode: CFRunLoopMode,
+  );
 
-    pub fn CFRunLoopTimerCreate(
-        allocator: CFAllocatorRef,
-        fireDate: CFAbsoluteTime,
-        interval: CFTimeInterval,
-        flags: CFOptionFlags,
-        order: CFIndex,
-        callout: CFRunLoopTimerCallBack,
-        context: *mut CFRunLoopTimerContext,
-    ) -> CFRunLoopTimerRef;
-    pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
-    pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
-    pub fn CFRunLoopTimerInvalidate(time: CFRunLoopTimerRef);
+  pub fn CFRunLoopTimerCreate(
+    allocator: CFAllocatorRef,
+    fireDate: CFAbsoluteTime,
+    interval: CFTimeInterval,
+    flags: CFOptionFlags,
+    order: CFIndex,
+    callout: CFRunLoopTimerCallBack,
+    context: *mut CFRunLoopTimerContext,
+  ) -> CFRunLoopTimerRef;
+  pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
+  pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
+  pub fn CFRunLoopTimerInvalidate(time: CFRunLoopTimerRef);
 
-    pub fn CFRunLoopSourceCreate(
-        allocator: CFAllocatorRef,
-        order: CFIndex,
-        context: *mut CFRunLoopSourceContext,
-    ) -> CFRunLoopSourceRef;
-    pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
-    #[allow(dead_code)]
-    pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
-    pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
+  pub fn CFRunLoopSourceCreate(
+    allocator: CFAllocatorRef,
+    order: CFIndex,
+    context: *mut CFRunLoopSourceContext,
+  ) -> CFRunLoopSourceRef;
+  pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
+  #[allow(dead_code)]
+  pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
+  pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
 
-    pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
-    pub fn CFRelease(cftype: *const c_void);
+  pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
+  pub fn CFRelease(cftype: *const c_void);
 }
 
 pub enum CFAllocator {}
@@ -93,7 +93,7 @@ pub const kCFRunLoopAfterWaiting: CFRunLoopActivity = 1 << 6;
 pub const kCFRunLoopExit: CFRunLoopActivity = 1 << 7;
 
 pub type CFRunLoopObserverCallBack =
-    extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
+  extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
 pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void);
 
 pub enum CFRunLoopTimerContext {}
@@ -103,197 +103,196 @@ pub enum CFRunLoopTimerContext {}
 #[allow(non_snake_case)]
 #[repr(C)]
 pub struct CFRunLoopObserverContext {
-    pub version: CFIndex,
-    pub info: *mut c_void,
-    pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
-    pub release: Option<extern "C" fn(info: *const c_void)>,
-    pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
+  pub version: CFIndex,
+  pub info: *mut c_void,
+  pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+  pub release: Option<extern "C" fn(info: *const c_void)>,
+  pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
 }
 
 #[allow(non_snake_case)]
 #[repr(C)]
 pub struct CFRunLoopSourceContext {
-    pub version: CFIndex,
-    pub info: *mut c_void,
-    pub retain: Option<extern "C" fn(*const c_void) -> *const c_void>,
-    pub release: Option<extern "C" fn(*const c_void)>,
-    pub copyDescription: Option<extern "C" fn(*const c_void) -> CFStringRef>,
-    pub equal: Option<extern "C" fn(*const c_void, *const c_void) -> ffi::Boolean>,
-    pub hash: Option<extern "C" fn(*const c_void) -> CFHashCode>,
-    pub schedule: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub cancel: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub perform: Option<extern "C" fn(*mut c_void)>,
+  pub version: CFIndex,
+  pub info: *mut c_void,
+  pub retain: Option<extern "C" fn(*const c_void) -> *const c_void>,
+  pub release: Option<extern "C" fn(*const c_void)>,
+  pub copyDescription: Option<extern "C" fn(*const c_void) -> CFStringRef>,
+  pub equal: Option<extern "C" fn(*const c_void, *const c_void) -> ffi::Boolean>,
+  pub hash: Option<extern "C" fn(*const c_void) -> CFHashCode>,
+  pub schedule: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
+  pub cancel: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
+  pub perform: Option<extern "C" fn(*mut c_void)>,
 }
 
 unsafe fn control_flow_handler<F>(panic_info: *mut c_void, f: F)
 where
-    F: FnOnce(Weak<PanicInfo>) + UnwindSafe,
+  F: FnOnce(Weak<PanicInfo>) + UnwindSafe,
 {
-    let info_from_raw = Weak::from_raw(panic_info as *mut PanicInfo);
-    // Asserting unwind safety on this type should be fine because `PanicInfo` is
-    // `RefUnwindSafe` and `Rc<T>` is `UnwindSafe` if `T` is `RefUnwindSafe`.
-    let panic_info = AssertUnwindSafe(Weak::clone(&info_from_raw));
-    // `from_raw` takes ownership of the data behind the pointer.
-    // But if this scope takes ownership of the weak pointer, then
-    // the weak pointer will get free'd at the end of the scope.
-    // However we want to keep that weak reference around after the function.
-    std::mem::forget(info_from_raw);
+  let info_from_raw = Weak::from_raw(panic_info as *mut PanicInfo);
+  // Asserting unwind safety on this type should be fine because `PanicInfo` is
+  // `RefUnwindSafe` and `Rc<T>` is `UnwindSafe` if `T` is `RefUnwindSafe`.
+  let panic_info = AssertUnwindSafe(Weak::clone(&info_from_raw));
+  // `from_raw` takes ownership of the data behind the pointer.
+  // But if this scope takes ownership of the weak pointer, then
+  // the weak pointer will get free'd at the end of the scope.
+  // However we want to keep that weak reference around after the function.
+  std::mem::forget(info_from_raw);
 
-    stop_app_on_panic(Weak::clone(&panic_info), move || f(panic_info.0));
+  stop_app_on_panic(Weak::clone(&panic_info), move || f(panic_info.0));
 }
 
 // begin is queued with the highest priority to ensure it is processed before other observers
 extern "C" fn control_flow_begin_handler(
-    _: CFRunLoopObserverRef,
-    activity: CFRunLoopActivity,
-    panic_info: *mut c_void,
+  _: CFRunLoopObserverRef,
+  activity: CFRunLoopActivity,
+  panic_info: *mut c_void,
 ) {
-    unsafe {
-        control_flow_handler(panic_info, |panic_info| {
-            #[allow(non_upper_case_globals)]
-            match activity {
-                kCFRunLoopAfterWaiting => {
-                    //trace!("Triggered `CFRunLoopAfterWaiting`");
-                    AppState::wakeup(panic_info);
-                    //trace!("Completed `CFRunLoopAfterWaiting`");
-                }
-                kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
-                _ => unreachable!(),
-            }
-        });
-    }
+  unsafe {
+    control_flow_handler(panic_info, |panic_info| {
+      #[allow(non_upper_case_globals)]
+      match activity {
+        kCFRunLoopAfterWaiting => {
+          //trace!("Triggered `CFRunLoopAfterWaiting`");
+          AppState::wakeup(panic_info);
+          //trace!("Completed `CFRunLoopAfterWaiting`");
+        }
+        kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
+        _ => unreachable!(),
+      }
+    });
+  }
 }
 
 // end is queued with the lowest priority to ensure it is processed after other observers
 // without that, LoopDestroyed would  get sent after MainEventsCleared
 extern "C" fn control_flow_end_handler(
-    _: CFRunLoopObserverRef,
-    activity: CFRunLoopActivity,
-    panic_info: *mut c_void,
+  _: CFRunLoopObserverRef,
+  activity: CFRunLoopActivity,
+  panic_info: *mut c_void,
 ) {
-    unsafe {
-        control_flow_handler(panic_info, |panic_info| {
-            #[allow(non_upper_case_globals)]
-            match activity {
-                kCFRunLoopBeforeWaiting => {
-                    //trace!("Triggered `CFRunLoopBeforeWaiting`");
-                    AppState::cleared(panic_info);
-                    //trace!("Completed `CFRunLoopBeforeWaiting`");
-                }
-                kCFRunLoopExit => (), //unimplemented!(), // not expected to ever happen
-                _ => unreachable!(),
-            }
-        });
-    }
+  unsafe {
+    control_flow_handler(panic_info, |panic_info| {
+      #[allow(non_upper_case_globals)]
+      match activity {
+        kCFRunLoopBeforeWaiting => {
+          //trace!("Triggered `CFRunLoopBeforeWaiting`");
+          AppState::cleared(panic_info);
+          //trace!("Completed `CFRunLoopBeforeWaiting`");
+        }
+        kCFRunLoopExit => (), //unimplemented!(), // not expected to ever happen
+        _ => unreachable!(),
+      }
+    });
+  }
 }
 
 struct RunLoop(CFRunLoopRef);
 
 impl RunLoop {
-    unsafe fn get() -> Self {
-        RunLoop(CFRunLoopGetMain())
-    }
+  unsafe fn get() -> Self {
+    RunLoop(CFRunLoopGetMain())
+  }
 
-    unsafe fn add_observer(
-        &self,
-        flags: CFOptionFlags,
-        priority: CFIndex,
-        handler: CFRunLoopObserverCallBack,
-        context: *mut CFRunLoopObserverContext,
-    ) {
-        let observer = CFRunLoopObserverCreate(
-            ptr::null_mut(),
-            flags,
-            ffi::TRUE, // Indicates we want this to run repeatedly
-            priority,  // The lower the value, the sooner this will run
-            handler,
-            context,
-        );
-        CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes);
-    }
+  unsafe fn add_observer(
+    &self,
+    flags: CFOptionFlags,
+    priority: CFIndex,
+    handler: CFRunLoopObserverCallBack,
+    context: *mut CFRunLoopObserverContext,
+  ) {
+    let observer = CFRunLoopObserverCreate(
+      ptr::null_mut(),
+      flags,
+      ffi::TRUE, // Indicates we want this to run repeatedly
+      priority,  // The lower the value, the sooner this will run
+      handler,
+      context,
+    );
+    CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes);
+  }
 }
 
 pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
-    unsafe {
-        let mut context = CFRunLoopObserverContext {
-            info: Weak::into_raw(panic_info) as *mut _,
-            version: 0,
-            retain: None,
-            release: None,
-            copyDescription: None,
-        };
-        let run_loop = RunLoop::get();
-        run_loop.add_observer(
-            kCFRunLoopEntry | kCFRunLoopAfterWaiting,
-            CFIndex::min_value(),
-            control_flow_begin_handler,
-            &mut context as *mut _,
-        );
-        run_loop.add_observer(
-            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
-            CFIndex::max_value(),
-            control_flow_end_handler,
-            &mut context as *mut _,
-        );
-    }
+  unsafe {
+    let mut context = CFRunLoopObserverContext {
+      info: Weak::into_raw(panic_info) as *mut _,
+      version: 0,
+      retain: None,
+      release: None,
+      copyDescription: None,
+    };
+    let run_loop = RunLoop::get();
+    run_loop.add_observer(
+      kCFRunLoopEntry | kCFRunLoopAfterWaiting,
+      CFIndex::min_value(),
+      control_flow_begin_handler,
+      &mut context as *mut _,
+    );
+    run_loop.add_observer(
+      kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+      CFIndex::max_value(),
+      control_flow_end_handler,
+      &mut context as *mut _,
+    );
+  }
 }
 
 pub struct EventLoopWaker {
-    timer: CFRunLoopTimerRef,
+  timer: CFRunLoopTimerRef,
 }
 
 impl Drop for EventLoopWaker {
-    fn drop(&mut self) {
-        unsafe {
-            CFRunLoopTimerInvalidate(self.timer);
-            CFRelease(self.timer as _);
-        }
+  fn drop(&mut self) {
+    unsafe {
+      CFRunLoopTimerInvalidate(self.timer);
+      CFRelease(self.timer as _);
     }
+  }
 }
 
 impl Default for EventLoopWaker {
-    fn default() -> EventLoopWaker {
-        extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
-        unsafe {
-            // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
-            // It is initially setup with a first fire time really far into the
-            // future, but that gets changed to fire immediately in did_finish_launching
-            let timer = CFRunLoopTimerCreate(
-                ptr::null_mut(),
-                std::f64::MAX,
-                0.000_000_1,
-                0,
-                0,
-                wakeup_main_loop,
-                ptr::null_mut(),
-            );
-            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
-            EventLoopWaker { timer }
-        }
+  fn default() -> EventLoopWaker {
+    extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
+    unsafe {
+      // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
+      // It is initially setup with a first fire time really far into the
+      // future, but that gets changed to fire immediately in did_finish_launching
+      let timer = CFRunLoopTimerCreate(
+        ptr::null_mut(),
+        std::f64::MAX,
+        0.000_000_1,
+        0,
+        0,
+        wakeup_main_loop,
+        ptr::null_mut(),
+      );
+      CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
+      EventLoopWaker { timer }
     }
+  }
 }
 
 impl EventLoopWaker {
-    pub fn stop(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
-    }
+  pub fn stop(&mut self) {
+    unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+  }
 
-    pub fn start(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
-    }
+  pub fn start(&mut self) {
+    unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+  }
 
-    pub fn start_at(&mut self, instant: Instant) {
-        let now = Instant::now();
-        if now >= instant {
-            self.start();
-        } else {
-            unsafe {
-                let current = CFAbsoluteTimeGetCurrent();
-                let duration = instant - now;
-                let fsecs =
-                    duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
-                CFRunLoopTimerSetNextFireDate(self.timer, current + fsecs)
-            }
-        }
+  pub fn start_at(&mut self, instant: Instant) {
+    let now = Instant::now();
+    if now >= instant {
+      self.start();
+    } else {
+      unsafe {
+        let current = CFAbsoluteTimeGetCurrent();
+        let duration = instant - now;
+        let fsecs = duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
+        CFRunLoopTimerSetNextFireDate(self.timer, current + fsecs)
+      }
     }
+  }
 }

src/platform_impl/macos/util/async.rs

@@ -1,20 +1,20 @@
 use std::{
-    ops::Deref,
-    sync::{Mutex, Weak},
+  ops::Deref,
+  sync::{Mutex, Weak},
 };
 
 use cocoa::{
-    appkit::{CGFloat, NSScreen, NSWindow, NSWindowStyleMask},
-    base::{id, nil},
-    foundation::{NSPoint, NSSize, NSString},
+  appkit::{CGFloat, NSScreen, NSWindow, NSWindowStyleMask},
+  base::{id, nil},
+  foundation::{NSPoint, NSSize, NSString},
 };
 use dispatch::Queue;
 use objc::rc::autoreleasepool;
 use objc::runtime::NO;
 
 use crate::{
-    dpi::LogicalSize,
-    platform_impl::platform::{ffi, util::IdRef, window::SharedState},
+  dpi::LogicalSize,
+  platform_impl::platform::{ffi, util::IdRef, window::SharedState},
 };
 
 // Unsafe wrapper type that allows us to dispatch things that aren't Send.
@@ -26,17 +26,17 @@ struct MainThreadSafe<T>(T);
 unsafe impl<T> Send for MainThreadSafe<T> {}
 
 impl<T> Deref for MainThreadSafe<T> {
-    type Target = T;
-    fn deref(&self) -> &T {
-        &self.0
-    }
+  type Target = T;
+  fn deref(&self) -> &T {
+    &self.0
+  }
 }
 
 unsafe fn set_style_mask(ns_window: id, ns_view: id, mask: NSWindowStyleMask) {
-    ns_window.setStyleMask_(mask);
-    // If we don't do this, key handling will break
-    // (at least until the window is clicked again/etc.)
-    ns_window.makeFirstResponder_(ns_view);
+  ns_window.setStyleMask_(mask);
+  // If we don't do this, key handling will break
+  // (at least until the window is clicked again/etc.)
+  ns_window.makeFirstResponder_(ns_view);
 }
 
 // Always use this function instead of trying to modify `styleMask` directly!
@@ -44,165 +44,165 @@ unsafe fn set_style_mask(ns_window: id, ns_view: id, mask: NSWindowStyleMask) {
 // Otherwise, this would vomit out errors about not being on the main thread
 // and fail to do anything.
 pub unsafe fn set_style_mask_async(ns_window: id, ns_view: id, mask: NSWindowStyleMask) {
-    let ns_window = MainThreadSafe(ns_window);
-    let ns_view = MainThreadSafe(ns_view);
-    Queue::main().exec_async(move || {
-        set_style_mask(*ns_window, *ns_view, mask);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  let ns_view = MainThreadSafe(ns_view);
+  Queue::main().exec_async(move || {
+    set_style_mask(*ns_window, *ns_view, mask);
+  });
 }
 pub unsafe fn set_style_mask_sync(ns_window: id, ns_view: id, mask: NSWindowStyleMask) {
-    if msg_send![class!(NSThread), isMainThread] {
-        set_style_mask(ns_window, ns_view, mask);
-    } else {
-        let ns_window = MainThreadSafe(ns_window);
-        let ns_view = MainThreadSafe(ns_view);
-        Queue::main().exec_sync(move || {
-            set_style_mask(*ns_window, *ns_view, mask);
-        })
-    }
+  if msg_send![class!(NSThread), isMainThread] {
+    set_style_mask(ns_window, ns_view, mask);
+  } else {
+    let ns_window = MainThreadSafe(ns_window);
+    let ns_view = MainThreadSafe(ns_view);
+    Queue::main().exec_sync(move || {
+      set_style_mask(*ns_window, *ns_view, mask);
+    })
+  }
 }
 
 // `setContentSize:` isn't thread-safe either, though it doesn't log any errors
 // and just fails silently. Anyway, GCD to the rescue!
 pub unsafe fn set_content_size_async(ns_window: id, size: LogicalSize<f64>) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        ns_window.setContentSize_(NSSize::new(size.width as CGFloat, size.height as CGFloat));
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    ns_window.setContentSize_(NSSize::new(size.width as CGFloat, size.height as CGFloat));
+  });
 }
 
 // `setFrameTopLeftPoint:` isn't thread-safe, but fortunately has the courtesy
 // to log errors.
 pub unsafe fn set_frame_top_left_point_async(ns_window: id, point: NSPoint) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        ns_window.setFrameTopLeftPoint_(point);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    ns_window.setFrameTopLeftPoint_(point);
+  });
 }
 
 // `setFrameTopLeftPoint:` isn't thread-safe, and fails silently.
 pub unsafe fn set_level_async(ns_window: id, level: ffi::NSWindowLevel) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        ns_window.setLevel_(level as _);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    ns_window.setLevel_(level as _);
+  });
 }
 
 // `toggleFullScreen` is thread-safe, but our additional logic to account for
 // window styles isn't.
 pub unsafe fn toggle_full_screen_async(
-    ns_window: id,
-    ns_view: id,
-    not_fullscreen: bool,
-    shared_state: Weak<Mutex<SharedState>>,
+  ns_window: id,
+  ns_view: id,
+  not_fullscreen: bool,
+  shared_state: Weak<Mutex<SharedState>>,
 ) {
-    let ns_window = MainThreadSafe(ns_window);
-    let ns_view = MainThreadSafe(ns_view);
-    let shared_state = MainThreadSafe(shared_state);
-    Queue::main().exec_async(move || {
-        // `toggleFullScreen` doesn't work if the `StyleMask` is none, so we
-        // set a normal style temporarily. The previous state will be
-        // restored in `WindowDelegate::window_did_exit_fullscreen`.
-        if not_fullscreen {
-            let curr_mask = ns_window.styleMask();
-            let required =
-                NSWindowStyleMask::NSTitledWindowMask | NSWindowStyleMask::NSResizableWindowMask;
-            if !curr_mask.contains(required) {
-                set_style_mask(*ns_window, *ns_view, required);
-                if let Some(shared_state) = shared_state.upgrade() {
-                    trace!("Locked shared state in `toggle_full_screen_callback`");
-                    let mut shared_state_lock = shared_state.lock().unwrap();
-                    (*shared_state_lock).saved_style = Some(curr_mask);
-                    trace!("Unlocked shared state in `toggle_full_screen_callback`");
-                }
-            }
+  let ns_window = MainThreadSafe(ns_window);
+  let ns_view = MainThreadSafe(ns_view);
+  let shared_state = MainThreadSafe(shared_state);
+  Queue::main().exec_async(move || {
+    // `toggleFullScreen` doesn't work if the `StyleMask` is none, so we
+    // set a normal style temporarily. The previous state will be
+    // restored in `WindowDelegate::window_did_exit_fullscreen`.
+    if not_fullscreen {
+      let curr_mask = ns_window.styleMask();
+      let required =
+        NSWindowStyleMask::NSTitledWindowMask | NSWindowStyleMask::NSResizableWindowMask;
+      if !curr_mask.contains(required) {
+        set_style_mask(*ns_window, *ns_view, required);
+        if let Some(shared_state) = shared_state.upgrade() {
+          trace!("Locked shared state in `toggle_full_screen_callback`");
+          let mut shared_state_lock = shared_state.lock().unwrap();
+          (*shared_state_lock).saved_style = Some(curr_mask);
+          trace!("Unlocked shared state in `toggle_full_screen_callback`");
         }
-        // Window level must be restored from `CGShieldingWindowLevel()
-        // + 1` back to normal in order for `toggleFullScreen` to do
-        // anything
-        ns_window.setLevel_(0);
-        ns_window.toggleFullScreen_(nil);
-    });
+      }
+    }
+    // Window level must be restored from `CGShieldingWindowLevel()
+    // + 1` back to normal in order for `toggleFullScreen` to do
+    // anything
+    ns_window.setLevel_(0);
+    ns_window.toggleFullScreen_(nil);
+  });
 }
 
 pub unsafe fn restore_display_mode_async(ns_screen: u32) {
-    Queue::main().exec_async(move || {
-        ffi::CGRestorePermanentDisplayConfiguration();
-        assert_eq!(ffi::CGDisplayRelease(ns_screen), ffi::kCGErrorSuccess);
-    });
+  Queue::main().exec_async(move || {
+    ffi::CGRestorePermanentDisplayConfiguration();
+    assert_eq!(ffi::CGDisplayRelease(ns_screen), ffi::kCGErrorSuccess);
+  });
 }
 
 // `setMaximized` is not thread-safe
 pub unsafe fn set_maximized_async(
-    ns_window: id,
-    is_zoomed: bool,
-    maximized: bool,
-    shared_state: Weak<Mutex<SharedState>>,
+  ns_window: id,
+  is_zoomed: bool,
+  maximized: bool,
+  shared_state: Weak<Mutex<SharedState>>,
 ) {
-    let ns_window = MainThreadSafe(ns_window);
-    let shared_state = MainThreadSafe(shared_state);
-    Queue::main().exec_async(move || {
-        if let Some(shared_state) = shared_state.upgrade() {
-            trace!("Locked shared state in `set_maximized`");
-            let mut shared_state_lock = shared_state.lock().unwrap();
+  let ns_window = MainThreadSafe(ns_window);
+  let shared_state = MainThreadSafe(shared_state);
+  Queue::main().exec_async(move || {
+    if let Some(shared_state) = shared_state.upgrade() {
+      trace!("Locked shared state in `set_maximized`");
+      let mut shared_state_lock = shared_state.lock().unwrap();
 
-            // Save the standard frame sized if it is not zoomed
-            if !is_zoomed {
-                shared_state_lock.standard_frame = Some(NSWindow::frame(*ns_window));
-            }
+      // Save the standard frame sized if it is not zoomed
+      if !is_zoomed {
+        shared_state_lock.standard_frame = Some(NSWindow::frame(*ns_window));
+      }
 
-            shared_state_lock.maximized = maximized;
+      shared_state_lock.maximized = maximized;
 
-            let curr_mask = ns_window.styleMask();
-            if shared_state_lock.fullscreen.is_some() {
-                // Handle it in window_did_exit_fullscreen
-                return;
-            } else if curr_mask.contains(NSWindowStyleMask::NSResizableWindowMask) {
-                // Just use the native zoom if resizable
-                ns_window.zoom_(nil);
-            } else {
-                // if it's not resizable, we set the frame directly
-                let new_rect = if maximized {
-                    let screen = NSScreen::mainScreen(nil);
-                    NSScreen::visibleFrame(screen)
-                } else {
-                    shared_state_lock.saved_standard_frame()
-                };
-                ns_window.setFrame_display_(new_rect, NO);
-            }
+      let curr_mask = ns_window.styleMask();
+      if shared_state_lock.fullscreen.is_some() {
+        // Handle it in window_did_exit_fullscreen
+        return;
+      } else if curr_mask.contains(NSWindowStyleMask::NSResizableWindowMask) {
+        // Just use the native zoom if resizable
+        ns_window.zoom_(nil);
+      } else {
+        // if it's not resizable, we set the frame directly
+        let new_rect = if maximized {
+          let screen = NSScreen::mainScreen(nil);
+          NSScreen::visibleFrame(screen)
+        } else {
+          shared_state_lock.saved_standard_frame()
+        };
+        ns_window.setFrame_display_(new_rect, NO);
+      }
 
-            trace!("Unlocked shared state in `set_maximized`");
-        }
-    });
+      trace!("Unlocked shared state in `set_maximized`");
+    }
+  });
 }
 
 // `orderOut:` isn't thread-safe. Calling it from another thread actually works,
 // but with an odd delay.
 pub unsafe fn order_out_async(ns_window: id) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        ns_window.orderOut_(nil);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    ns_window.orderOut_(nil);
+  });
 }
 
 // `makeKeyAndOrderFront:` isn't thread-safe. Calling it from another thread
 // actually works, but with an odd delay.
 pub unsafe fn make_key_and_order_front_async(ns_window: id) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        ns_window.makeKeyAndOrderFront_(nil);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    ns_window.makeKeyAndOrderFront_(nil);
+  });
 }
 
 // `setTitle:` isn't thread-safe. Calling it from another thread invalidates the
 // window drag regions, which throws an exception when not done in the main
 // thread
 pub unsafe fn set_title_async(ns_window: id, title: String) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        let title = IdRef::new(NSString::alloc(nil).init_str(&title));
-        ns_window.setTitle_(*title);
-    });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    let title = IdRef::new(NSString::alloc(nil).init_str(&title));
+    ns_window.setTitle_(*title);
+  });
 }
 
 // `close:` is thread-safe, but we want the event to be triggered from the main
@@ -211,10 +211,10 @@ pub unsafe fn set_title_async(ns_window: id, title: String) {
 // ArturKovacs: It's important that this operation keeps the underlying window alive
 // through the `IdRef` because otherwise it would dereference free'd memory
 pub unsafe fn close_async(ns_window: IdRef) {
-    let ns_window = MainThreadSafe(ns_window);
-    Queue::main().exec_async(move || {
-        autoreleasepool(move || {
-            ns_window.close();
-        });
+  let ns_window = MainThreadSafe(ns_window);
+  Queue::main().exec_async(move || {
+    autoreleasepool(move || {
+      ns_window.close();
     });
+  });
 }

src/platform_impl/macos/util/cursor.rs

@@ -1,7 +1,7 @@
 use cocoa::{
-    appkit::NSImage,
-    base::{id, nil},
-    foundation::{NSDictionary, NSPoint, NSString},
+  appkit::NSImage,
+  base::{id, nil},
+  foundation::{NSDictionary, NSPoint, NSString},
 };
 use objc::{runtime::Sel, runtime::NO};
 use std::cell::RefCell;
@@ -9,156 +9,152 @@ use std::cell::RefCell;
 use crate::window::CursorIcon;
 
 pub enum Cursor {
-    Native(&'static str),
-    Undocumented(&'static str),
-    WebKit(&'static str),
+  Native(&'static str),
+  Undocumented(&'static str),
+  WebKit(&'static str),
 }
 
 impl From<CursorIcon> for Cursor {
-    fn from(cursor: CursorIcon) -> Self {
-        // See native cursors at https://developer.apple.com/documentation/appkit/nscursor?language=objc.
-        match cursor {
-            CursorIcon::Arrow | CursorIcon::Default => Cursor::Native("arrowCursor"),
-            CursorIcon::Hand => Cursor::Native("pointingHandCursor"),
-            CursorIcon::Grab => Cursor::Native("openHandCursor"),
-            CursorIcon::Grabbing => Cursor::Native("closedHandCursor"),
-            CursorIcon::Text => Cursor::Native("IBeamCursor"),
-            CursorIcon::VerticalText => Cursor::Native("IBeamCursorForVerticalLayout"),
-            CursorIcon::Copy => Cursor::Native("dragCopyCursor"),
-            CursorIcon::Alias => Cursor::Native("dragLinkCursor"),
-            CursorIcon::NotAllowed | CursorIcon::NoDrop => {
-                Cursor::Native("operationNotAllowedCursor")
-            }
-            CursorIcon::ContextMenu => Cursor::Native("contextualMenuCursor"),
-            CursorIcon::Crosshair => Cursor::Native("crosshairCursor"),
-            CursorIcon::EResize => Cursor::Native("resizeRightCursor"),
-            CursorIcon::NResize => Cursor::Native("resizeUpCursor"),
-            CursorIcon::WResize => Cursor::Native("resizeLeftCursor"),
-            CursorIcon::SResize => Cursor::Native("resizeDownCursor"),
-            CursorIcon::EwResize | CursorIcon::ColResize => Cursor::Native("resizeLeftRightCursor"),
-            CursorIcon::NsResize | CursorIcon::RowResize => Cursor::Native("resizeUpDownCursor"),
+  fn from(cursor: CursorIcon) -> Self {
+    // See native cursors at https://developer.apple.com/documentation/appkit/nscursor?language=objc.
+    match cursor {
+      CursorIcon::Arrow | CursorIcon::Default => Cursor::Native("arrowCursor"),
+      CursorIcon::Hand => Cursor::Native("pointingHandCursor"),
+      CursorIcon::Grab => Cursor::Native("openHandCursor"),
+      CursorIcon::Grabbing => Cursor::Native("closedHandCursor"),
+      CursorIcon::Text => Cursor::Native("IBeamCursor"),
+      CursorIcon::VerticalText => Cursor::Native("IBeamCursorForVerticalLayout"),
+      CursorIcon::Copy => Cursor::Native("dragCopyCursor"),
+      CursorIcon::Alias => Cursor::Native("dragLinkCursor"),
+      CursorIcon::NotAllowed | CursorIcon::NoDrop => Cursor::Native("operationNotAllowedCursor"),
+      CursorIcon::ContextMenu => Cursor::Native("contextualMenuCursor"),
+      CursorIcon::Crosshair => Cursor::Native("crosshairCursor"),
+      CursorIcon::EResize => Cursor::Native("resizeRightCursor"),
+      CursorIcon::NResize => Cursor::Native("resizeUpCursor"),
+      CursorIcon::WResize => Cursor::Native("resizeLeftCursor"),
+      CursorIcon::SResize => Cursor::Native("resizeDownCursor"),
+      CursorIcon::EwResize | CursorIcon::ColResize => Cursor::Native("resizeLeftRightCursor"),
+      CursorIcon::NsResize | CursorIcon::RowResize => Cursor::Native("resizeUpDownCursor"),
 
-            // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
-            CursorIcon::Help => Cursor::Undocumented("_helpCursor"),
-            CursorIcon::ZoomIn => Cursor::Undocumented("_zoomInCursor"),
-            CursorIcon::ZoomOut => Cursor::Undocumented("_zoomOutCursor"),
-            CursorIcon::NeResize => Cursor::Undocumented("_windowResizeNorthEastCursor"),
-            CursorIcon::NwResize => Cursor::Undocumented("_windowResizeNorthWestCursor"),
-            CursorIcon::SeResize => Cursor::Undocumented("_windowResizeSouthEastCursor"),
-            CursorIcon::SwResize => Cursor::Undocumented("_windowResizeSouthWestCursor"),
-            CursorIcon::NeswResize => Cursor::Undocumented("_windowResizeNorthEastSouthWestCursor"),
-            CursorIcon::NwseResize => Cursor::Undocumented("_windowResizeNorthWestSouthEastCursor"),
+      // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
+      CursorIcon::Help => Cursor::Undocumented("_helpCursor"),
+      CursorIcon::ZoomIn => Cursor::Undocumented("_zoomInCursor"),
+      CursorIcon::ZoomOut => Cursor::Undocumented("_zoomOutCursor"),
+      CursorIcon::NeResize => Cursor::Undocumented("_windowResizeNorthEastCursor"),
+      CursorIcon::NwResize => Cursor::Undocumented("_windowResizeNorthWestCursor"),
+      CursorIcon::SeResize => Cursor::Undocumented("_windowResizeSouthEastCursor"),
+      CursorIcon::SwResize => Cursor::Undocumented("_windowResizeSouthWestCursor"),
+      CursorIcon::NeswResize => Cursor::Undocumented("_windowResizeNorthEastSouthWestCursor"),
+      CursorIcon::NwseResize => Cursor::Undocumented("_windowResizeNorthWestSouthEastCursor"),
 
-            // While these are available, the former just loads a white arrow,
-            // and the latter loads an ugly deflated beachball!
-            // CursorIcon::Move => Cursor::Undocumented("_moveCursor"),
-            // CursorIcon::Wait => Cursor::Undocumented("_waitCursor"),
+      // While these are available, the former just loads a white arrow,
+      // and the latter loads an ugly deflated beachball!
+      // CursorIcon::Move => Cursor::Undocumented("_moveCursor"),
+      // CursorIcon::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.
-            CursorIcon::Wait | CursorIcon::Progress => {
-                Cursor::Undocumented("busyButClickableCursor")
-            }
+      // 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.
+      CursorIcon::Wait | CursorIcon::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
-            CursorIcon::Move | CursorIcon::AllScroll => Cursor::WebKit("move"),
-            CursorIcon::Cell => Cursor::WebKit("cell"),
-        }
+      // 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
+      CursorIcon::Move | CursorIcon::AllScroll => Cursor::WebKit("move"),
+      CursorIcon::Cell => Cursor::WebKit("cell"),
     }
+  }
 }
 
 impl Default for Cursor {
-    fn default() -> Self {
-        Cursor::Native("arrowCursor")
-    }
+  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),
-        }
+  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),
     }
+  }
 }
 
 // Note that loading `busybutclickable` with this code won't animate the frames;
 // instead you'll just get them all in a column.
 pub unsafe fn load_webkit_cursor(cursor_name: &str) -> id {
-    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);
-    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");
+  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);
+  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 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);
-    let info = NSDictionary::dictionaryWithContentsOfFile_(nil, info_path);
-    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];
-    msg_send![cursor,
-        initWithImage:image
-        hotSpot:point
-    ]
+  let image = NSImage::alloc(nil).initByReferencingFile_(pdf_path);
+  let info = NSDictionary::dictionaryWithContentsOfFile_(nil, info_path);
+  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];
+  msg_send![cursor,
+      initWithImage:image
+      hotSpot:point
+  ]
 }
 
 pub unsafe fn invisible_cursor() -> id {
-    // 16x16 GIF data for invisible cursor
-    // You can reproduce this via ImageMagick.
-    // $ convert -size 16x16 xc:none cursor.gif
-    static CURSOR_BYTES: &[u8] = &[
-        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x21, 0xF9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00,
-        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0E, 0x84, 0x8F, 0xA9, 0xCB, 0xED, 0x0F,
-        0xA3, 0x9C, 0xB4, 0xDA, 0x8B, 0xB3, 0x3E, 0x05, 0x00, 0x3B,
-    ];
+  // 16x16 GIF data for invisible cursor
+  // You can reproduce this via ImageMagick.
+  // $ convert -size 16x16 xc:none cursor.gif
+  static CURSOR_BYTES: &[u8] = &[
+    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x21, 0xF9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0E, 0x84, 0x8F, 0xA9, 0xCB, 0xED, 0x0F, 0xA3, 0x9C, 0xB4,
+    0xDA, 0x8B, 0xB3, 0x3E, 0x05, 0x00, 0x3B,
+  ];
 
-    thread_local! {
-        // We can't initialize this at startup.
-        static CURSOR_OBJECT: RefCell<id> = RefCell::new(nil);
+  thread_local! {
+      // We can't initialize this at startup.
+      static CURSOR_OBJECT: RefCell<id> = RefCell::new(nil);
+  }
+
+  CURSOR_OBJECT.with(|cursor_obj| {
+    if *cursor_obj.borrow() == nil {
+      // Create a cursor from `CURSOR_BYTES`
+      let cursor_data: id = msg_send![class!(NSData),
+          dataWithBytesNoCopy:CURSOR_BYTES as *const [u8]
+          length:CURSOR_BYTES.len()
+          freeWhenDone:NO
+      ];
+
+      let ns_image: id = msg_send![class!(NSImage), alloc];
+      let _: id = msg_send![ns_image, initWithData: cursor_data];
+      let cursor: id = msg_send![class!(NSCursor), alloc];
+      *cursor_obj.borrow_mut() =
+        msg_send![cursor, initWithImage:ns_image hotSpot: NSPoint::new(0.0, 0.0)];
     }
-
-    CURSOR_OBJECT.with(|cursor_obj| {
-        if *cursor_obj.borrow() == nil {
-            // Create a cursor from `CURSOR_BYTES`
-            let cursor_data: id = msg_send![class!(NSData),
-                dataWithBytesNoCopy:CURSOR_BYTES as *const [u8]
-                length:CURSOR_BYTES.len()
-                freeWhenDone:NO
-            ];
-
-            let ns_image: id = msg_send![class!(NSImage), alloc];
-            let _: id = msg_send![ns_image, initWithData: cursor_data];
-            let cursor: id = msg_send![class!(NSCursor), alloc];
-            *cursor_obj.borrow_mut() =
-                msg_send![cursor, initWithImage:ns_image hotSpot: NSPoint::new(0.0, 0.0)];
-        }
-        *cursor_obj.borrow()
-    })
+    *cursor_obj.borrow()
+  })
 }

src/platform_impl/macos/util/mod.rs

@@ -6,9 +6,9 @@ pub use self::{cursor::*, r#async::*};
 use std::ops::{BitAnd, Deref};
 
 use cocoa::{
-    appkit::{NSApp, NSWindowStyleMask},
-    base::{id, nil},
-    foundation::{NSAutoreleasePool, NSPoint, NSRect, NSString, NSUInteger},
+  appkit::{NSApp, NSWindowStyleMask},
+  base::{id, nil},
+  foundation::{NSAutoreleasePool, NSPoint, NSRect, NSString, NSUInteger},
 };
 use core_graphics::display::CGDisplay;
 use objc::runtime::{Class, Object, Sel, BOOL, YES};
@@ -22,133 +22,133 @@ pub enum Never {}
 
 pub fn has_flag<T>(bitset: T, flag: T) -> bool
 where
-    T: Copy + PartialEq + BitAnd<T, Output = T>,
+  T: Copy + PartialEq + BitAnd<T, Output = T>,
 {
-    bitset & flag == flag
+  bitset & flag == flag
 }
 
 pub const EMPTY_RANGE: ffi::NSRange = ffi::NSRange {
-    location: ffi::NSNotFound as NSUInteger,
-    length: 0,
+  location: ffi::NSNotFound as NSUInteger,
+  length: 0,
 };
 
 #[derive(Debug, PartialEq)]
 pub struct IdRef(id);
 
 impl IdRef {
-    pub fn new(inner: id) -> IdRef {
-        IdRef(inner)
-    }
+  pub fn new(inner: id) -> IdRef {
+    IdRef(inner)
+  }
 
-    #[allow(dead_code)]
-    pub fn retain(inner: id) -> IdRef {
-        if inner != nil {
-            let () = unsafe { msg_send![inner, retain] };
-        }
-        IdRef(inner)
+  #[allow(dead_code)]
+  pub fn retain(inner: id) -> IdRef {
+    if inner != nil {
+      let () = unsafe { msg_send![inner, retain] };
     }
+    IdRef(inner)
+  }
 
-    pub fn non_nil(self) -> Option<IdRef> {
-        if self.0 == nil {
-            None
-        } else {
-            Some(self)
-        }
+  pub fn non_nil(self) -> Option<IdRef> {
+    if self.0 == nil {
+      None
+    } else {
+      Some(self)
     }
+  }
 }
 
 impl Drop for IdRef {
-    fn drop(&mut self) {
-        if self.0 != nil {
-            unsafe {
-                let pool = NSAutoreleasePool::new(nil);
-                let () = msg_send![self.0, release];
-                pool.drain();
-            };
-        }
+  fn drop(&mut self) {
+    if self.0 != nil {
+      unsafe {
+        let pool = NSAutoreleasePool::new(nil);
+        let () = msg_send![self.0, release];
+        pool.drain();
+      };
     }
+  }
 }
 
 impl Deref for IdRef {
-    type Target = id;
-    fn deref<'a>(&'a self) -> &'a id {
-        &self.0
-    }
+  type Target = id;
+  fn deref<'a>(&'a self) -> &'a id {
+    &self.0
+  }
 }
 
 impl Clone for IdRef {
-    fn clone(&self) -> IdRef {
-        if self.0 != nil {
-            let _: id = unsafe { msg_send![self.0, retain] };
-        }
-        IdRef(self.0)
+  fn clone(&self) -> IdRef {
+    if self.0 != nil {
+      let _: id = unsafe { msg_send![self.0, retain] };
     }
+    IdRef(self.0)
+  }
 }
 
 // For consistency with other platforms, this will...
 // 1. translate the bottom-left window corner into the top-left window corner
 // 2. translate the coordinate from a bottom-left origin coordinate system to a top-left one
 pub fn bottom_left_to_top_left(rect: NSRect) -> f64 {
-    CGDisplay::main().pixels_high() as f64 - (rect.origin.y + rect.size.height)
+  CGDisplay::main().pixels_high() as f64 - (rect.origin.y + rect.size.height)
 }
 
 /// Converts from winit screen-coordinates to macOS screen-coordinates.
 /// Winit: top-left is (0, 0) and y increasing downwards
 /// macOS: bottom-left is (0, 0) and y increasing upwards
 pub fn window_position(position: LogicalPosition<f64>) -> NSPoint {
-    NSPoint::new(
-        position.x,
-        CGDisplay::main().pixels_high() as f64 - position.y,
-    )
+  NSPoint::new(
+    position.x,
+    CGDisplay::main().pixels_high() as f64 - position.y,
+  )
 }
 
 pub unsafe fn ns_string_id_ref(s: &str) -> IdRef {
-    IdRef::new(NSString::alloc(nil).init_str(s))
+  IdRef::new(NSString::alloc(nil).init_str(s))
 }
 
 #[allow(dead_code)] // In case we want to use this function in the future
 pub unsafe fn app_name() -> Option<id> {
-    let bundle: id = msg_send![class!(NSBundle), mainBundle];
-    let dict: id = msg_send![bundle, infoDictionary];
-    let key = ns_string_id_ref("CFBundleName");
-    let app_name: id = msg_send![dict, objectForKey:*key];
-    if app_name != nil {
-        Some(app_name)
-    } else {
-        None
-    }
+  let bundle: id = msg_send![class!(NSBundle), mainBundle];
+  let dict: id = msg_send![bundle, infoDictionary];
+  let key = ns_string_id_ref("CFBundleName");
+  let app_name: id = msg_send![dict, objectForKey:*key];
+  if app_name != nil {
+    Some(app_name)
+  } else {
+    None
+  }
 }
 
 pub unsafe fn superclass<'a>(this: &'a Object) -> &'a Class {
-    let superclass: id = msg_send![this, superclass];
-    &*(superclass as *const _)
+  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];
-    IdRef::new(input_context)
+  let input_context: id = msg_send![class!(NSTextInputContext), alloc];
+  let input_context: id = msg_send![input_context, initWithClient: view];
+  IdRef::new(input_context)
 }
 
 #[allow(dead_code)]
 pub unsafe fn open_emoji_picker() {
-    let () = msg_send![NSApp(), orderFrontCharacterPalette: nil];
+  let () = msg_send![NSApp(), orderFrontCharacterPalette: nil];
 }
 
 pub extern "C" fn yes(_: &Object, _: Sel) -> BOOL {
-    YES
+  YES
 }
 
 pub unsafe fn toggle_style_mask(window: id, view: id, mask: NSWindowStyleMask, on: bool) {
-    use cocoa::appkit::NSWindow;
+  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));
-    }
+  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);
+  // If we don't do this, key handling will break. Therefore, never call `setStyleMask` directly!
+  window.makeFirstResponder_(view);
 }

src/platform_impl/macos/window_delegate.rs

@@ -1,141 +1,140 @@
 use std::{
-    f64,
-    os::raw::c_void,
-    sync::{atomic::Ordering, Arc, Weak},
+  f64,
+  os::raw::c_void,
+  sync::{atomic::Ordering, Arc, Weak},
 };
 
 use cocoa::{
-    appkit::{self, NSApplicationPresentationOptions, NSView, NSWindow},
-    base::{id, nil},
-    foundation::{NSAutoreleasePool, NSUInteger},
+  appkit::{self, NSApplicationPresentationOptions, NSView, NSWindow},
+  base::{id, nil},
+  foundation::{NSAutoreleasePool, NSUInteger},
 };
 use objc::{
-    declare::ClassDecl,
-    runtime::{Class, Object, Sel, BOOL, NO, YES},
+  declare::ClassDecl,
+  runtime::{Class, Object, Sel, BOOL, NO, YES},
 };
 
 use crate::{
-    dpi::{LogicalPosition, LogicalSize},
-    event::{Event, ModifiersState, WindowEvent},
-    platform_impl::platform::{
-        app_state::AppState,
-        app_state::INTERRUPT_EVENT_LOOP_EXIT,
-        event::{EventProxy, EventWrapper},
-        util::{self, IdRef},
-        view::ViewState,
-        window::{get_window_id, UnownedWindow},
-    },
-    window::{Fullscreen, WindowId},
+  dpi::{LogicalPosition, LogicalSize},
+  event::{Event, ModifiersState, WindowEvent},
+  platform_impl::platform::{
+    app_state::AppState,
+    app_state::INTERRUPT_EVENT_LOOP_EXIT,
+    event::{EventProxy, EventWrapper},
+    util::{self, IdRef},
+    view::ViewState,
+    window::{get_window_id, UnownedWindow},
+  },
+  window::{Fullscreen, WindowId},
 };
 
 pub struct WindowDelegateState {
-    ns_window: IdRef, // never changes
-    ns_view: IdRef,   // never changes
+  ns_window: IdRef, // never changes
+  ns_view: IdRef,   // never changes
 
-    window: Weak<UnownedWindow>,
+  window: Weak<UnownedWindow>,
 
-    // TODO: It's possible for delegate methods to be called asynchronously,
-    // causing data races / `RefCell` panics.
+  // TODO: It's possible for delegate methods to be called asynchronously,
+  // causing data races / `RefCell` panics.
 
-    // This is set when WindowBuilder::with_fullscreen was set,
-    // see comments of `window_did_fail_to_enter_fullscreen`
-    initial_fullscreen: bool,
+  // This is set when WindowBuilder::with_fullscreen was set,
+  // see comments of `window_did_fail_to_enter_fullscreen`
+  initial_fullscreen: bool,
 
-    // During `windowDidResize`, we use this to only send Moved if the position changed.
-    previous_position: Option<(f64, f64)>,
+  // During `windowDidResize`, we use this to only send Moved if the position changed.
+  previous_position: Option<(f64, f64)>,
 
-    // Used to prevent redundant events.
-    previous_scale_factor: f64,
+  // Used to prevent redundant events.
+  previous_scale_factor: f64,
 }
 
 impl WindowDelegateState {
-    pub fn new(window: &Arc<UnownedWindow>, initial_fullscreen: bool) -> Self {
-        let scale_factor = window.scale_factor();
-        let mut delegate_state = WindowDelegateState {
-            ns_window: window.ns_window.clone(),
-            ns_view: window.ns_view.clone(),
-            window: Arc::downgrade(&window),
-            initial_fullscreen,
-            previous_position: None,
-            previous_scale_factor: scale_factor,
-        };
-
-        if scale_factor != 1.0 {
-            delegate_state.emit_static_scale_factor_changed_event();
-        }
-
-        delegate_state
+  pub fn new(window: &Arc<UnownedWindow>, initial_fullscreen: bool) -> Self {
+    let scale_factor = window.scale_factor();
+    let mut delegate_state = WindowDelegateState {
+      ns_window: window.ns_window.clone(),
+      ns_view: window.ns_view.clone(),
+      window: Arc::downgrade(&window),
+      initial_fullscreen,
+      previous_position: None,
+      previous_scale_factor: scale_factor,
+    };
+    if (scale_factor - 1.0).abs() > f64::EPSILON {
+      delegate_state.emit_static_scale_factor_changed_event();
     }
 
-    fn with_window<F, T>(&mut self, callback: F) -> Option<T>
-    where
-        F: FnOnce(&UnownedWindow) -> T,
-    {
-        self.window.upgrade().map(|ref window| callback(window))
-    }
+    delegate_state
+  }
 
-    pub fn emit_event(&mut self, event: WindowEvent<'static>) {
-        let event = Event::WindowEvent {
-            window_id: WindowId(get_window_id(*self.ns_window)),
-            event,
-        };
-        AppState::queue_event(EventWrapper::StaticEvent(event));
-    }
+  fn with_window<F, T>(&mut self, callback: F) -> Option<T>
+  where
+    F: FnOnce(&UnownedWindow) -> T,
+  {
+    self.window.upgrade().map(|ref window| callback(window))
+  }
 
-    pub fn emit_static_scale_factor_changed_event(&mut self) {
-        let scale_factor = self.get_scale_factor();
-        if scale_factor == self.previous_scale_factor {
-            return ();
-        };
+  pub fn emit_event(&mut self, event: WindowEvent<'static>) {
+    let event = Event::WindowEvent {
+      window_id: WindowId(get_window_id(*self.ns_window)),
+      event,
+    };
+    AppState::queue_event(EventWrapper::StaticEvent(event));
+  }
 
-        self.previous_scale_factor = scale_factor;
-        let wrapper = EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
-            ns_window: IdRef::retain(*self.ns_window),
-            suggested_size: self.view_size(),
-            scale_factor,
-        });
-        AppState::queue_event(wrapper);
-    }
+  pub fn emit_static_scale_factor_changed_event(&mut self) {
+    let scale_factor = self.get_scale_factor();
+    if (scale_factor - self.previous_scale_factor).abs() < f64::EPSILON {
+      return ();
+    };
 
-    pub fn emit_resize_event(&mut self) {
-        let rect = unsafe { NSView::frame(*self.ns_view) };
-        let scale_factor = self.get_scale_factor();
-        let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
-        let size = logical_size.to_physical(scale_factor);
-        self.emit_event(WindowEvent::Resized(size));
-    }
+    self.previous_scale_factor = scale_factor;
+    let wrapper = EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
+      ns_window: IdRef::retain(*self.ns_window),
+      suggested_size: self.view_size(),
+      scale_factor,
+    });
+    AppState::queue_event(wrapper);
+  }
 
-    fn emit_move_event(&mut self) {
-        let rect = unsafe { NSWindow::frame(*self.ns_window) };
-        let x = rect.origin.x as f64;
-        let y = util::bottom_left_to_top_left(rect);
-        let moved = self.previous_position != Some((x, y));
-        if moved {
-            self.previous_position = Some((x, y));
-            let scale_factor = self.get_scale_factor();
-            let physical_pos = LogicalPosition::<f64>::from((x, y)).to_physical(scale_factor);
-            self.emit_event(WindowEvent::Moved(physical_pos));
-        }
-    }
+  pub fn emit_resize_event(&mut self) {
+    let rect = unsafe { NSView::frame(*self.ns_view) };
+    let scale_factor = self.get_scale_factor();
+    let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
+    let size = logical_size.to_physical(scale_factor);
+    self.emit_event(WindowEvent::Resized(size));
+  }
 
-    fn get_scale_factor(&self) -> f64 {
-        (unsafe { NSWindow::backingScaleFactor(*self.ns_window) }) as f64
+  fn emit_move_event(&mut self) {
+    let rect = unsafe { NSWindow::frame(*self.ns_window) };
+    let x = rect.origin.x as f64;
+    let y = util::bottom_left_to_top_left(rect);
+    let moved = self.previous_position != Some((x, y));
+    if moved {
+      self.previous_position = Some((x, y));
+      let scale_factor = self.get_scale_factor();
+      let physical_pos = LogicalPosition::<f64>::from((x, y)).to_physical(scale_factor);
+      self.emit_event(WindowEvent::Moved(physical_pos));
     }
+  }
 
-    fn view_size(&self) -> LogicalSize<f64> {
-        let ns_size = unsafe { NSView::frame(*self.ns_view).size };
-        LogicalSize::new(ns_size.width as f64, ns_size.height as f64)
-    }
+  fn get_scale_factor(&self) -> f64 {
+    (unsafe { NSWindow::backingScaleFactor(*self.ns_window) }) as f64
+  }
+
+  fn view_size(&self) -> LogicalSize<f64> {
+    let ns_size = unsafe { NSView::frame(*self.ns_view).size };
+    LogicalSize::new(ns_size.width as f64, ns_size.height as f64)
+  }
 }
 
 pub fn new_delegate(window: &Arc<UnownedWindow>, initial_fullscreen: bool) -> IdRef {
-    let state = WindowDelegateState::new(window, initial_fullscreen);
-    unsafe {
-        // This is free'd in `dealloc`
-        let state_ptr = Box::into_raw(Box::new(state)) as *mut c_void;
-        let delegate: id = msg_send![WINDOW_DELEGATE_CLASS.0, alloc];
-        IdRef::new(msg_send![delegate, initWithWinit: state_ptr])
-    }
+  let state = WindowDelegateState::new(window, initial_fullscreen);
+  unsafe {
+    // This is free'd in `dealloc`
+    let state_ptr = Box::into_raw(Box::new(state)) as *mut c_void;
+    let delegate: id = msg_send![WINDOW_DELEGATE_CLASS.0, alloc];
+    IdRef::new(msg_send![delegate, initWithWinit: state_ptr])
+  }
 }
 
 struct WindowDelegateClass(*const Class);
@@ -143,405 +142,405 @@ unsafe impl Send for WindowDelegateClass {}
 unsafe impl Sync for WindowDelegateClass {}
 
 lazy_static! {
-    static ref WINDOW_DELEGATE_CLASS: WindowDelegateClass = unsafe {
-        let superclass = class!(NSResponder);
-        let mut decl = ClassDecl::new("WinitWindowDelegate", superclass).unwrap();
+  static ref WINDOW_DELEGATE_CLASS: WindowDelegateClass = unsafe {
+    let superclass = class!(NSResponder);
+    let mut decl = ClassDecl::new("WinitWindowDelegate", superclass).unwrap();
 
-        decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
-        decl.add_method(
-            sel!(initWithWinit:),
-            init_with_winit as extern "C" fn(&Object, Sel, *mut c_void) -> id,
-        );
+    decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
+    decl.add_method(
+      sel!(initWithWinit:),
+      init_with_winit as extern "C" fn(&Object, Sel, *mut c_void) -> id,
+    );
 
-        decl.add_method(
-            sel!(windowShouldClose:),
-            window_should_close as extern "C" fn(&Object, Sel, id) -> BOOL,
-        );
-        decl.add_method(
-            sel!(windowWillClose:),
-            window_will_close as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidResize:),
-            window_did_resize as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidMove:),
-            window_did_move as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidChangeBackingProperties:),
-            window_did_change_backing_properties as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidBecomeKey:),
-            window_did_become_key as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidResignKey:),
-            window_did_resign_key as extern "C" fn(&Object, Sel, id),
-        );
+    decl.add_method(
+      sel!(windowShouldClose:),
+      window_should_close as extern "C" fn(&Object, Sel, id) -> BOOL,
+    );
+    decl.add_method(
+      sel!(windowWillClose:),
+      window_will_close as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidResize:),
+      window_did_resize as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidMove:),
+      window_did_move as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidChangeBackingProperties:),
+      window_did_change_backing_properties as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidBecomeKey:),
+      window_did_become_key as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidResignKey:),
+      window_did_resign_key as extern "C" fn(&Object, Sel, id),
+    );
 
-        decl.add_method(
-            sel!(draggingEntered:),
-            dragging_entered as extern "C" fn(&Object, Sel, id) -> BOOL,
-        );
-        decl.add_method(
-            sel!(prepareForDragOperation:),
-            prepare_for_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
-        );
-        decl.add_method(
-            sel!(performDragOperation:),
-            perform_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
-        );
-        decl.add_method(
-            sel!(concludeDragOperation:),
-            conclude_drag_operation as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(draggingExited:),
-            dragging_exited as extern "C" fn(&Object, Sel, id),
-        );
+    decl.add_method(
+      sel!(draggingEntered:),
+      dragging_entered as extern "C" fn(&Object, Sel, id) -> BOOL,
+    );
+    decl.add_method(
+      sel!(prepareForDragOperation:),
+      prepare_for_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
+    );
+    decl.add_method(
+      sel!(performDragOperation:),
+      perform_drag_operation as extern "C" fn(&Object, Sel, id) -> BOOL,
+    );
+    decl.add_method(
+      sel!(concludeDragOperation:),
+      conclude_drag_operation as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(draggingExited:),
+      dragging_exited as extern "C" fn(&Object, Sel, id),
+    );
 
-        decl.add_method(
-            sel!(window:willUseFullScreenPresentationOptions:),
-            window_will_use_fullscreen_presentation_options
-                as extern "C" fn(&Object, Sel, id, NSUInteger) -> NSUInteger,
-        );
-        decl.add_method(
-            sel!(windowDidEnterFullScreen:),
-            window_did_enter_fullscreen as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowWillEnterFullScreen:),
-            window_will_enter_fullscreen as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidExitFullScreen:),
-            window_did_exit_fullscreen as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowWillExitFullScreen:),
-            window_will_exit_fullscreen as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(windowDidFailToEnterFullScreen:),
-            window_did_fail_to_enter_fullscreen as extern "C" fn(&Object, Sel, id),
-        );
+    decl.add_method(
+      sel!(window:willUseFullScreenPresentationOptions:),
+      window_will_use_fullscreen_presentation_options
+        as extern "C" fn(&Object, Sel, id, NSUInteger) -> NSUInteger,
+    );
+    decl.add_method(
+      sel!(windowDidEnterFullScreen:),
+      window_did_enter_fullscreen as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowWillEnterFullScreen:),
+      window_will_enter_fullscreen as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidExitFullScreen:),
+      window_did_exit_fullscreen as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowWillExitFullScreen:),
+      window_will_exit_fullscreen as extern "C" fn(&Object, Sel, id),
+    );
+    decl.add_method(
+      sel!(windowDidFailToEnterFullScreen:),
+      window_did_fail_to_enter_fullscreen as extern "C" fn(&Object, Sel, id),
+    );
 
-        decl.add_ivar::<*mut c_void>("winitState");
-        WindowDelegateClass(decl.register())
-    };
+    decl.add_ivar::<*mut c_void>("winitState");
+    WindowDelegateClass(decl.register())
+  };
 }
 
 // This function is definitely unsafe, but labeling that would increase
 // boilerplate and wouldn't really clarify anything...
 fn with_state<F: FnOnce(&mut WindowDelegateState) -> T, T>(this: &Object, callback: F) {
-    let state_ptr = unsafe {
-        let state_ptr: *mut c_void = *this.get_ivar("winitState");
-        &mut *(state_ptr as *mut WindowDelegateState)
-    };
-    callback(state_ptr);
+  let state_ptr = unsafe {
+    let state_ptr: *mut c_void = *this.get_ivar("winitState");
+    &mut *(state_ptr as *mut WindowDelegateState)
+  };
+  callback(state_ptr);
 }
 
 extern "C" fn dealloc(this: &Object, _sel: Sel) {
-    with_state(this, |state| unsafe {
-        Box::from_raw(state as *mut WindowDelegateState);
-    });
+  with_state(this, |state| unsafe {
+    Box::from_raw(state as *mut WindowDelegateState);
+  });
 }
 
 extern "C" fn init_with_winit(this: &Object, _sel: Sel, state: *mut c_void) -> id {
-    unsafe {
-        let this: id = msg_send![this, init];
-        if this != nil {
-            (*this).set_ivar("winitState", state);
-            with_state(&*this, |state| {
-                let () = msg_send![*state.ns_window, setDelegate: this];
-            });
-        }
-        this
+  unsafe {
+    let this: id = msg_send![this, init];
+    if this != nil {
+      (*this).set_ivar("winitState", state);
+      with_state(&*this, |state| {
+        let () = msg_send![*state.ns_window, setDelegate: this];
+      });
     }
+    this
+  }
 }
 
 extern "C" fn window_should_close(this: &Object, _: Sel, _: id) -> BOOL {
-    trace!("Triggered `windowShouldClose:`");
-    with_state(this, |state| state.emit_event(WindowEvent::CloseRequested));
-    trace!("Completed `windowShouldClose:`");
-    NO
+  trace!("Triggered `windowShouldClose:`");
+  with_state(this, |state| state.emit_event(WindowEvent::CloseRequested));
+  trace!("Completed `windowShouldClose:`");
+  NO
 }
 
 extern "C" fn window_will_close(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowWillClose:`");
-    with_state(this, |state| unsafe {
-        // `setDelegate:` retains the previous value and then autoreleases it
-        let pool = NSAutoreleasePool::new(nil);
-        // Since El Capitan, we need to be careful that delegate methods can't
-        // be called after the window closes.
-        let () = msg_send![*state.ns_window, setDelegate: nil];
-        pool.drain();
-        state.emit_event(WindowEvent::Destroyed);
-    });
-    trace!("Completed `windowWillClose:`");
+  trace!("Triggered `windowWillClose:`");
+  with_state(this, |state| unsafe {
+    // `setDelegate:` retains the previous value and then autoreleases it
+    let pool = NSAutoreleasePool::new(nil);
+    // Since El Capitan, we need to be careful that delegate methods can't
+    // be called after the window closes.
+    let () = msg_send![*state.ns_window, setDelegate: nil];
+    pool.drain();
+    state.emit_event(WindowEvent::Destroyed);
+  });
+  trace!("Completed `windowWillClose:`");
 }
 
 extern "C" fn window_did_resize(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidResize:`");
-    with_state(this, |state| {
-        state.emit_resize_event();
-        state.emit_move_event();
-    });
-    trace!("Completed `windowDidResize:`");
+  trace!("Triggered `windowDidResize:`");
+  with_state(this, |state| {
+    state.emit_resize_event();
+    state.emit_move_event();
+  });
+  trace!("Completed `windowDidResize:`");
 }
 
 // This won't be triggered if the move was part of a resize.
 extern "C" fn window_did_move(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidMove:`");
-    with_state(this, |state| {
-        state.emit_move_event();
-    });
-    trace!("Completed `windowDidMove:`");
+  trace!("Triggered `windowDidMove:`");
+  with_state(this, |state| {
+    state.emit_move_event();
+  });
+  trace!("Completed `windowDidMove:`");
 }
 
 extern "C" fn window_did_change_backing_properties(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidChangeBackingProperties:`");
-    with_state(this, |state| {
-        state.emit_static_scale_factor_changed_event();
-    });
-    trace!("Completed `windowDidChangeBackingProperties:`");
+  trace!("Triggered `windowDidChangeBackingProperties:`");
+  with_state(this, |state| {
+    state.emit_static_scale_factor_changed_event();
+  });
+  trace!("Completed `windowDidChangeBackingProperties:`");
 }
 
 extern "C" fn window_did_become_key(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidBecomeKey:`");
-    with_state(this, |state| {
-        // TODO: center the cursor if the window had mouse grab when it
-        // lost focus
-        state.emit_event(WindowEvent::Focused(true));
-    });
-    trace!("Completed `windowDidBecomeKey:`");
+  trace!("Triggered `windowDidBecomeKey:`");
+  with_state(this, |state| {
+    // TODO: center the cursor if the window had mouse grab when it
+    // lost focus
+    state.emit_event(WindowEvent::Focused(true));
+  });
+  trace!("Completed `windowDidBecomeKey:`");
 }
 
 extern "C" fn window_did_resign_key(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidResignKey:`");
-    with_state(this, |state| {
-        // It happens rather often, e.g. when the user is Cmd+Tabbing, that the
-        // NSWindowDelegate will receive a didResignKey event despite no event
-        // being received when the modifiers are released.  This is because
-        // flagsChanged events are received by the NSView instead of the
-        // NSWindowDelegate, and as a result a tracked modifiers state can quite
-        // easily fall out of synchrony with reality.  This requires us to emit
-        // a synthetic ModifiersChanged event when we lose focus.
-        //
-        // Here we (very unsafely) acquire the winitState (a ViewState) from the
-        // Object referenced by state.ns_view (an IdRef, which is dereferenced
-        // to an id)
-        let view_state: &mut ViewState = unsafe {
-            let ns_view: &Object = (*state.ns_view).as_ref().expect("failed to deref");
-            let state_ptr: *mut c_void = *ns_view.get_ivar("winitState");
-            &mut *(state_ptr as *mut ViewState)
-        };
+  trace!("Triggered `windowDidResignKey:`");
+  with_state(this, |state| {
+    // It happens rather often, e.g. when the user is Cmd+Tabbing, that the
+    // NSWindowDelegate will receive a didResignKey event despite no event
+    // being received when the modifiers are released.  This is because
+    // flagsChanged events are received by the NSView instead of the
+    // NSWindowDelegate, and as a result a tracked modifiers state can quite
+    // easily fall out of synchrony with reality.  This requires us to emit
+    // a synthetic ModifiersChanged event when we lose focus.
+    //
+    // Here we (very unsafely) acquire the winitState (a ViewState) from the
+    // Object referenced by state.ns_view (an IdRef, which is dereferenced
+    // to an id)
+    let view_state: &mut ViewState = unsafe {
+      let ns_view: &Object = (*state.ns_view).as_ref().expect("failed to deref");
+      let state_ptr: *mut c_void = *ns_view.get_ivar("winitState");
+      &mut *(state_ptr as *mut ViewState)
+    };
 
-        // Both update the state and emit a ModifiersChanged event.
-        if !view_state.modifiers.is_empty() {
-            view_state.modifiers = ModifiersState::empty();
-            state.emit_event(WindowEvent::ModifiersChanged(view_state.modifiers));
-        }
+    // Both update the state and emit a ModifiersChanged event.
+    if !view_state.modifiers.is_empty() {
+      view_state.modifiers = ModifiersState::empty();
+      state.emit_event(WindowEvent::ModifiersChanged(view_state.modifiers));
+    }
 
-        state.emit_event(WindowEvent::Focused(false));
-    });
-    trace!("Completed `windowDidResignKey:`");
+    state.emit_event(WindowEvent::Focused(false));
+  });
+  trace!("Completed `windowDidResignKey:`");
 }
 
 /// Invoked when the dragged image enters destination bounds or frame
 extern "C" fn dragging_entered(this: &Object, _: Sel, sender: id) -> BOOL {
-    trace!("Triggered `draggingEntered:`");
+  trace!("Triggered `draggingEntered:`");
 
-    use cocoa::{appkit::NSPasteboard, foundation::NSFastEnumeration};
-    use std::path::PathBuf;
+  use cocoa::{appkit::NSPasteboard, foundation::NSFastEnumeration};
+  use std::path::PathBuf;
 
-    let pb: id = unsafe { msg_send![sender, draggingPasteboard] };
-    let filenames = unsafe { NSPasteboard::propertyListForType(pb, appkit::NSFilenamesPboardType) };
+  let pb: id = unsafe { msg_send![sender, draggingPasteboard] };
+  let filenames = unsafe { NSPasteboard::propertyListForType(pb, appkit::NSFilenamesPboardType) };
 
-    for file in unsafe { filenames.iter() } {
-        use cocoa::foundation::NSString;
-        use std::ffi::CStr;
+  for file in unsafe { filenames.iter() } {
+    use cocoa::foundation::NSString;
+    use std::ffi::CStr;
 
-        unsafe {
-            let f = NSString::UTF8String(file);
-            let path = CStr::from_ptr(f).to_string_lossy().into_owned();
+    unsafe {
+      let f = NSString::UTF8String(file);
+      let path = CStr::from_ptr(f).to_string_lossy().into_owned();
 
-            with_state(this, |state| {
-                state.emit_event(WindowEvent::HoveredFile(PathBuf::from(path)));
-            });
-        }
+      with_state(this, |state| {
+        state.emit_event(WindowEvent::HoveredFile(PathBuf::from(path)));
+      });
     }
+  }
 
-    trace!("Completed `draggingEntered:`");
-    YES
+  trace!("Completed `draggingEntered:`");
+  YES
 }
 
 /// Invoked when the image is released
 extern "C" fn prepare_for_drag_operation(_: &Object, _: Sel, _: id) -> BOOL {
-    trace!("Triggered `prepareForDragOperation:`");
-    trace!("Completed `prepareForDragOperation:`");
-    YES
+  trace!("Triggered `prepareForDragOperation:`");
+  trace!("Completed `prepareForDragOperation:`");
+  YES
 }
 
 /// Invoked after the released image has been removed from the screen
 extern "C" fn perform_drag_operation(this: &Object, _: Sel, sender: id) -> BOOL {
-    trace!("Triggered `performDragOperation:`");
+  trace!("Triggered `performDragOperation:`");
 
-    use cocoa::{appkit::NSPasteboard, foundation::NSFastEnumeration};
-    use std::path::PathBuf;
+  use cocoa::{appkit::NSPasteboard, foundation::NSFastEnumeration};
+  use std::path::PathBuf;
 
-    let pb: id = unsafe { msg_send![sender, draggingPasteboard] };
-    let filenames = unsafe { NSPasteboard::propertyListForType(pb, appkit::NSFilenamesPboardType) };
+  let pb: id = unsafe { msg_send![sender, draggingPasteboard] };
+  let filenames = unsafe { NSPasteboard::propertyListForType(pb, appkit::NSFilenamesPboardType) };
 
-    for file in unsafe { filenames.iter() } {
-        use cocoa::foundation::NSString;
-        use std::ffi::CStr;
+  for file in unsafe { filenames.iter() } {
+    use cocoa::foundation::NSString;
+    use std::ffi::CStr;
 
-        unsafe {
-            let f = NSString::UTF8String(file);
-            let path = CStr::from_ptr(f).to_string_lossy().into_owned();
+    unsafe {
+      let f = NSString::UTF8String(file);
+      let path = CStr::from_ptr(f).to_string_lossy().into_owned();
 
-            with_state(this, |state| {
-                state.emit_event(WindowEvent::DroppedFile(PathBuf::from(path)));
-            });
-        }
+      with_state(this, |state| {
+        state.emit_event(WindowEvent::DroppedFile(PathBuf::from(path)));
+      });
     }
+  }
 
-    trace!("Completed `performDragOperation:`");
-    YES
+  trace!("Completed `performDragOperation:`");
+  YES
 }
 
 /// Invoked when the dragging operation is complete
 extern "C" fn conclude_drag_operation(_: &Object, _: Sel, _: id) {
-    trace!("Triggered `concludeDragOperation:`");
-    trace!("Completed `concludeDragOperation:`");
+  trace!("Triggered `concludeDragOperation:`");
+  trace!("Completed `concludeDragOperation:`");
 }
 
 /// Invoked when the dragging operation is cancelled
 extern "C" fn dragging_exited(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `draggingExited:`");
-    with_state(this, |state| {
-        state.emit_event(WindowEvent::HoveredFileCancelled)
-    });
-    trace!("Completed `draggingExited:`");
+  trace!("Triggered `draggingExited:`");
+  with_state(this, |state| {
+    state.emit_event(WindowEvent::HoveredFileCancelled)
+  });
+  trace!("Completed `draggingExited:`");
 }
 
 /// Invoked when before enter fullscreen
 extern "C" fn window_will_enter_fullscreen(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowWillEnterFullscreen:`");
+  trace!("Triggered `windowWillEnterFullscreen:`");
 
-    INTERRUPT_EVENT_LOOP_EXIT.store(true, Ordering::SeqCst);
+  INTERRUPT_EVENT_LOOP_EXIT.store(true, Ordering::SeqCst);
 
-    with_state(this, |state| {
-        state.with_window(|window| {
-            trace!("Locked shared state in `window_will_enter_fullscreen`");
-            let mut shared_state = window.shared_state.lock().unwrap();
-            shared_state.maximized = window.is_zoomed();
-            match shared_state.fullscreen {
-                // Exclusive mode sets the state in `set_fullscreen` as the user
-                // can't enter exclusive mode by other means (like the
-                // fullscreen button on the window decorations)
-                Some(Fullscreen::Exclusive(_)) => (),
-                // `window_will_enter_fullscreen` was triggered and we're already
-                // in fullscreen, so we must've reached here by `set_fullscreen`
-                // as it updates the state
-                Some(Fullscreen::Borderless(_)) => (),
-                // Otherwise, we must've reached fullscreen by the user clicking
-                // on the green fullscreen button. Update state!
-                None => {
-                    let current_monitor = Some(window.current_monitor_inner());
-                    shared_state.fullscreen = Some(Fullscreen::Borderless(current_monitor))
-                }
-            }
-            shared_state.in_fullscreen_transition = true;
-            trace!("Unlocked shared state in `window_will_enter_fullscreen`");
-        })
-    });
-    trace!("Completed `windowWillEnterFullscreen:`");
+  with_state(this, |state| {
+    state.with_window(|window| {
+      trace!("Locked shared state in `window_will_enter_fullscreen`");
+      let mut shared_state = window.shared_state.lock().unwrap();
+      shared_state.maximized = window.is_zoomed();
+      match shared_state.fullscreen {
+        // Exclusive mode sets the state in `set_fullscreen` as the user
+        // can't enter exclusive mode by other means (like the
+        // fullscreen button on the window decorations)
+        Some(Fullscreen::Exclusive(_)) => (),
+        // `window_will_enter_fullscreen` was triggered and we're already
+        // in fullscreen, so we must've reached here by `set_fullscreen`
+        // as it updates the state
+        Some(Fullscreen::Borderless(_)) => (),
+        // Otherwise, we must've reached fullscreen by the user clicking
+        // on the green fullscreen button. Update state!
+        None => {
+          let current_monitor = Some(window.current_monitor_inner());
+          shared_state.fullscreen = Some(Fullscreen::Borderless(current_monitor))
+        }
+      }
+      shared_state.in_fullscreen_transition = true;
+      trace!("Unlocked shared state in `window_will_enter_fullscreen`");
+    })
+  });
+  trace!("Completed `windowWillEnterFullscreen:`");
 }
 
 /// Invoked when before exit fullscreen
 extern "C" fn window_will_exit_fullscreen(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowWillExitFullScreen:`");
+  trace!("Triggered `windowWillExitFullScreen:`");
 
-    INTERRUPT_EVENT_LOOP_EXIT.store(true, Ordering::SeqCst);
+  INTERRUPT_EVENT_LOOP_EXIT.store(true, Ordering::SeqCst);
 
-    with_state(this, |state| {
-        state.with_window(|window| {
-            trace!("Locked shared state in `window_will_exit_fullscreen`");
-            let mut shared_state = window.shared_state.lock().unwrap();
-            shared_state.in_fullscreen_transition = true;
-            trace!("Unlocked shared state in `window_will_exit_fullscreen`");
-        });
+  with_state(this, |state| {
+    state.with_window(|window| {
+      trace!("Locked shared state in `window_will_exit_fullscreen`");
+      let mut shared_state = window.shared_state.lock().unwrap();
+      shared_state.in_fullscreen_transition = true;
+      trace!("Unlocked shared state in `window_will_exit_fullscreen`");
     });
-    trace!("Completed `windowWillExitFullScreen:`");
+  });
+  trace!("Completed `windowWillExitFullScreen:`");
 }
 
 extern "C" fn window_will_use_fullscreen_presentation_options(
-    _this: &Object,
-    _: Sel,
-    _: id,
-    _proposed_options: NSUInteger,
+  _this: &Object,
+  _: Sel,
+  _: id,
+  _proposed_options: NSUInteger,
 ) -> NSUInteger {
-    // Generally, games will want to disable the menu bar and the dock. Ideally,
-    // this would be configurable by the user. Unfortunately because of our
-    // `CGShieldingWindowLevel() + 1` hack (see `set_fullscreen`), our window is
-    // placed on top of the menu bar in exclusive fullscreen mode. This looks
-    // broken so we always disable the menu bar in exclusive fullscreen. We may
-    // still want to make this configurable for borderless fullscreen. Right now
-    // we don't, for consistency. If we do, it should be documented that the
-    // user-provided options are ignored in exclusive fullscreen.
-    (NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
-        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
-        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar)
-        .bits()
+  // Generally, games will want to disable the menu bar and the dock. Ideally,
+  // this would be configurable by the user. Unfortunately because of our
+  // `CGShieldingWindowLevel() + 1` hack (see `set_fullscreen`), our window is
+  // placed on top of the menu bar in exclusive fullscreen mode. This looks
+  // broken so we always disable the menu bar in exclusive fullscreen. We may
+  // still want to make this configurable for borderless fullscreen. Right now
+  // we don't, for consistency. If we do, it should be documented that the
+  // user-provided options are ignored in exclusive fullscreen.
+  (NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+    | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+    | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar)
+    .bits()
 }
 
 /// Invoked when entered fullscreen
 extern "C" fn window_did_enter_fullscreen(this: &Object, _: Sel, _: id) {
-    INTERRUPT_EVENT_LOOP_EXIT.store(false, Ordering::SeqCst);
+  INTERRUPT_EVENT_LOOP_EXIT.store(false, Ordering::SeqCst);
 
-    trace!("Triggered `windowDidEnterFullscreen:`");
-    with_state(this, |state| {
-        state.initial_fullscreen = false;
-        state.with_window(|window| {
-            trace!("Locked shared state in `window_did_enter_fullscreen`");
-            let mut shared_state = window.shared_state.lock().unwrap();
-            shared_state.in_fullscreen_transition = false;
-            let target_fullscreen = shared_state.target_fullscreen.take();
-            trace!("Unlocked shared state in `window_did_enter_fullscreen`");
-            drop(shared_state);
-            if let Some(target_fullscreen) = target_fullscreen {
-                window.set_fullscreen(target_fullscreen);
-            }
-        });
+  trace!("Triggered `windowDidEnterFullscreen:`");
+  with_state(this, |state| {
+    state.initial_fullscreen = false;
+    state.with_window(|window| {
+      trace!("Locked shared state in `window_did_enter_fullscreen`");
+      let mut shared_state = window.shared_state.lock().unwrap();
+      shared_state.in_fullscreen_transition = false;
+      let target_fullscreen = shared_state.target_fullscreen.take();
+      trace!("Unlocked shared state in `window_did_enter_fullscreen`");
+      drop(shared_state);
+      if let Some(target_fullscreen) = target_fullscreen {
+        window.set_fullscreen(target_fullscreen);
+      }
     });
-    trace!("Completed `windowDidEnterFullscreen:`");
+  });
+  trace!("Completed `windowDidEnterFullscreen:`");
 }
 
 /// Invoked when exited fullscreen
 extern "C" fn window_did_exit_fullscreen(this: &Object, _: Sel, _: id) {
-    INTERRUPT_EVENT_LOOP_EXIT.store(false, Ordering::SeqCst);
+  INTERRUPT_EVENT_LOOP_EXIT.store(false, Ordering::SeqCst);
 
-    trace!("Triggered `windowDidExitFullscreen:`");
-    with_state(this, |state| {
-        state.with_window(|window| {
-            window.restore_state_from_fullscreen();
-            trace!("Locked shared state in `window_did_exit_fullscreen`");
-            let mut shared_state = window.shared_state.lock().unwrap();
-            shared_state.in_fullscreen_transition = false;
-            let target_fullscreen = shared_state.target_fullscreen.take();
-            trace!("Unlocked shared state in `window_did_exit_fullscreen`");
-            drop(shared_state);
-            if let Some(target_fullscreen) = target_fullscreen {
-                window.set_fullscreen(target_fullscreen);
-            }
-        })
-    });
-    trace!("Completed `windowDidExitFullscreen:`");
+  trace!("Triggered `windowDidExitFullscreen:`");
+  with_state(this, |state| {
+    state.with_window(|window| {
+      window.restore_state_from_fullscreen();
+      trace!("Locked shared state in `window_did_exit_fullscreen`");
+      let mut shared_state = window.shared_state.lock().unwrap();
+      shared_state.in_fullscreen_transition = false;
+      let target_fullscreen = shared_state.target_fullscreen.take();
+      trace!("Unlocked shared state in `window_did_exit_fullscreen`");
+      drop(shared_state);
+      if let Some(target_fullscreen) = target_fullscreen {
+        window.set_fullscreen(target_fullscreen);
+      }
+    })
+  });
+  trace!("Completed `windowDidExitFullscreen:`");
 }
 
 /// Invoked when fail to enter fullscreen
@@ -561,26 +560,26 @@ extern "C" fn window_did_exit_fullscreen(this: &Object, _: Sel, _: id) {
 /// This method indicates that there was an error, and you should clean up any
 /// work you may have done to prepare to enter full-screen mode.
 extern "C" fn window_did_fail_to_enter_fullscreen(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `windowDidFailToEnterFullscreen:`");
-    with_state(this, |state| {
-        state.with_window(|window| {
-            trace!("Locked shared state in `window_did_fail_to_enter_fullscreen`");
-            let mut shared_state = window.shared_state.lock().unwrap();
-            shared_state.in_fullscreen_transition = false;
-            shared_state.target_fullscreen = None;
-            trace!("Unlocked shared state in `window_did_fail_to_enter_fullscreen`");
-        });
-        if state.initial_fullscreen {
-            let _: () = unsafe {
-                msg_send![*state.ns_window,
-                    performSelector:sel!(toggleFullScreen:)
-                    withObject:nil
-                    afterDelay: 0.5
-                ]
-            };
-        } else {
-            state.with_window(|window| window.restore_state_from_fullscreen());
-        }
+  trace!("Triggered `windowDidFailToEnterFullscreen:`");
+  with_state(this, |state| {
+    state.with_window(|window| {
+      trace!("Locked shared state in `window_did_fail_to_enter_fullscreen`");
+      let mut shared_state = window.shared_state.lock().unwrap();
+      shared_state.in_fullscreen_transition = false;
+      shared_state.target_fullscreen = None;
+      trace!("Unlocked shared state in `window_did_fail_to_enter_fullscreen`");
     });
-    trace!("Completed `windowDidFailToEnterFullscreen:`");
+    if state.initial_fullscreen {
+      let _: () = unsafe {
+        msg_send![*state.ns_window,
+            performSelector:sel!(toggleFullScreen:)
+            withObject:nil
+            afterDelay: 0.5
+        ]
+      };
+    } else {
+      state.with_window(|window| window.restore_state_from_fullscreen());
+    }
+  });
+  trace!("Completed `windowDidFailToEnterFullscreen:`");
 }

src/platform_impl/mod.rs

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

src/platform_impl/windows/dark_mode.rs

@@ -4,14 +4,14 @@ use std::ffi::OsStr;
 use std::os::windows::ffi::OsStrExt;
 
 use winapi::{
-    shared::{
-        basetsd::SIZE_T,
-        minwindef::{BOOL, DWORD, FALSE, UINT, ULONG, WORD},
-        ntdef::{LPSTR, NTSTATUS, NT_SUCCESS, PVOID, WCHAR},
-        windef::HWND,
-        winerror::S_OK,
-    },
-    um::{libloaderapi, uxtheme, winuser},
+  shared::{
+    basetsd::SIZE_T,
+    minwindef::{BOOL, DWORD, FALSE, UINT, ULONG, WORD},
+    ntdef::{LPSTR, NTSTATUS, NT_SUCCESS, PVOID, WCHAR},
+    windef::HWND,
+    winerror::S_OK,
+  },
+  um::{libloaderapi, uxtheme, winuser},
 };
 
 use crate::window::Theme;
@@ -75,110 +75,110 @@ lazy_static! {
 /// Attempt to set a theme on a window, if necessary.
 /// Returns the theme that was picked
 pub fn try_theme(hwnd: HWND, preferred_theme: Option<Theme>) -> Theme {
-    if *DARK_MODE_SUPPORTED {
-        let is_dark_mode = match preferred_theme {
-            Some(theme) => theme == Theme::Dark,
-            None => should_use_dark_mode(),
-        };
+  if *DARK_MODE_SUPPORTED {
+    let is_dark_mode = match preferred_theme {
+      Some(theme) => theme == Theme::Dark,
+      None => should_use_dark_mode(),
+    };
 
-        let theme = if is_dark_mode {
-            Theme::Dark
-        } else {
-            Theme::Light
-        };
-        let theme_name = match theme {
-            Theme::Dark => DARK_THEME_NAME.as_ptr(),
-            Theme::Light => LIGHT_THEME_NAME.as_ptr(),
-        };
+    let theme = if is_dark_mode {
+      Theme::Dark
+    } else {
+      Theme::Light
+    };
+    let theme_name = match theme {
+      Theme::Dark => DARK_THEME_NAME.as_ptr(),
+      Theme::Light => LIGHT_THEME_NAME.as_ptr(),
+    };
 
-        let status = unsafe { uxtheme::SetWindowTheme(hwnd, theme_name as _, std::ptr::null()) };
+    let status = unsafe { uxtheme::SetWindowTheme(hwnd, theme_name as _, std::ptr::null()) };
 
-        if status == S_OK && set_dark_mode_for_window(hwnd, is_dark_mode) {
-            return theme;
-        }
+    if status == S_OK && set_dark_mode_for_window(hwnd, is_dark_mode) {
+      return theme;
     }
+  }
 
-    Theme::Light
+  Theme::Light
 }
 
 fn set_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) -> bool {
-    // Uses Windows undocumented API SetWindowCompositionAttribute,
-    // as seen in win32-darkmode example linked at top of file.
+  // Uses Windows undocumented API SetWindowCompositionAttribute,
+  // as seen in win32-darkmode example linked at top of file.
 
-    type SetWindowCompositionAttribute =
-        unsafe extern "system" fn(HWND, *mut WINDOWCOMPOSITIONATTRIBDATA) -> BOOL;
+  type SetWindowCompositionAttribute =
+    unsafe extern "system" fn(HWND, *mut WINDOWCOMPOSITIONATTRIBDATA) -> BOOL;
 
-    #[allow(non_snake_case)]
-    type WINDOWCOMPOSITIONATTRIB = u32;
-    const WCA_USEDARKMODECOLORS: WINDOWCOMPOSITIONATTRIB = 26;
+  #[allow(non_snake_case)]
+  type WINDOWCOMPOSITIONATTRIB = u32;
+  const WCA_USEDARKMODECOLORS: WINDOWCOMPOSITIONATTRIB = 26;
 
-    #[allow(non_snake_case)]
-    #[repr(C)]
-    struct WINDOWCOMPOSITIONATTRIBDATA {
-        Attrib: WINDOWCOMPOSITIONATTRIB,
-        pvData: PVOID,
-        cbData: SIZE_T,
-    }
-
-    lazy_static! {
-        static ref SET_WINDOW_COMPOSITION_ATTRIBUTE: Option<SetWindowCompositionAttribute> =
-            get_function!("user32.dll", SetWindowCompositionAttribute);
-    }
-
-    if let Some(set_window_composition_attribute) = *SET_WINDOW_COMPOSITION_ATTRIBUTE {
-        unsafe {
-            // SetWindowCompositionAttribute needs a bigbool (i32), not bool.
-            let mut is_dark_mode_bigbool = is_dark_mode as BOOL;
-
-            let mut data = WINDOWCOMPOSITIONATTRIBDATA {
-                Attrib: WCA_USEDARKMODECOLORS,
-                pvData: &mut is_dark_mode_bigbool as *mut _ as _,
-                cbData: std::mem::size_of_val(&is_dark_mode_bigbool) as _,
-            };
-
-            let status = set_window_composition_attribute(hwnd, &mut data as *mut _);
-
-            status != FALSE
-        }
-    } else {
-        false
+  #[allow(non_snake_case)]
+  #[repr(C)]
+  struct WINDOWCOMPOSITIONATTRIBDATA {
+    Attrib: WINDOWCOMPOSITIONATTRIB,
+    pvData: PVOID,
+    cbData: SIZE_T,
+  }
+
+  lazy_static! {
+    static ref SET_WINDOW_COMPOSITION_ATTRIBUTE: Option<SetWindowCompositionAttribute> =
+      get_function!("user32.dll", SetWindowCompositionAttribute);
+  }
+
+  if let Some(set_window_composition_attribute) = *SET_WINDOW_COMPOSITION_ATTRIBUTE {
+    unsafe {
+      // SetWindowCompositionAttribute needs a bigbool (i32), not bool.
+      let mut is_dark_mode_bigbool = is_dark_mode as BOOL;
+
+      let mut data = WINDOWCOMPOSITIONATTRIBDATA {
+        Attrib: WCA_USEDARKMODECOLORS,
+        pvData: &mut is_dark_mode_bigbool as *mut _ as _,
+        cbData: std::mem::size_of_val(&is_dark_mode_bigbool) as _,
+      };
+
+      let status = set_window_composition_attribute(hwnd, &mut data as *mut _);
+
+      status != FALSE
     }
+  } else {
+    false
+  }
 }
 
 fn should_use_dark_mode() -> bool {
-    should_apps_use_dark_mode() && !is_high_contrast()
+  should_apps_use_dark_mode() && !is_high_contrast()
 }
 
 fn should_apps_use_dark_mode() -> bool {
-    type ShouldAppsUseDarkMode = unsafe extern "system" fn() -> bool;
-    lazy_static! {
-        static ref SHOULD_APPS_USE_DARK_MODE: Option<ShouldAppsUseDarkMode> = {
-            unsafe {
-                const UXTHEME_SHOULDAPPSUSEDARKMODE_ORDINAL: WORD = 132;
+  type ShouldAppsUseDarkMode = unsafe extern "system" fn() -> bool;
+  lazy_static! {
+    static ref SHOULD_APPS_USE_DARK_MODE: Option<ShouldAppsUseDarkMode> = {
+      unsafe {
+        const UXTHEME_SHOULDAPPSUSEDARKMODE_ORDINAL: WORD = 132;
 
-                let module = libloaderapi::LoadLibraryA("uxtheme.dll\0".as_ptr() as _);
+        let module = libloaderapi::LoadLibraryA("uxtheme.dll\0".as_ptr() as _);
 
-                if module.is_null() {
-                    return None;
-                }
+        if module.is_null() {
+          return None;
+        }
 
-                let handle = libloaderapi::GetProcAddress(
-                    module,
-                    winuser::MAKEINTRESOURCEA(UXTHEME_SHOULDAPPSUSEDARKMODE_ORDINAL),
-                );
+        let handle = libloaderapi::GetProcAddress(
+          module,
+          winuser::MAKEINTRESOURCEA(UXTHEME_SHOULDAPPSUSEDARKMODE_ORDINAL),
+        );
 
-                if handle.is_null() {
-                    None
-                } else {
-                    Some(std::mem::transmute(handle))
-                }
-            }
-        };
-    }
+        if handle.is_null() {
+          None
+        } else {
+          Some(std::mem::transmute(handle))
+        }
+      }
+    };
+  }
 
-    SHOULD_APPS_USE_DARK_MODE
-        .map(|should_apps_use_dark_mode| unsafe { (should_apps_use_dark_mode)() })
-        .unwrap_or(false)
+  SHOULD_APPS_USE_DARK_MODE
+    .map(|should_apps_use_dark_mode| unsafe { (should_apps_use_dark_mode)() })
+    .unwrap_or(false)
 }
 
 // FIXME: This definition was missing from winapi. Can remove from
@@ -187,35 +187,35 @@ fn should_apps_use_dark_mode() -> bool {
 #[repr(C)]
 #[allow(non_snake_case)]
 struct HIGHCONTRASTA {
-    cbSize: UINT,
-    dwFlags: DWORD,
-    lpszDefaultScheme: LPSTR,
+  cbSize: UINT,
+  dwFlags: DWORD,
+  lpszDefaultScheme: LPSTR,
 }
 
 const HCF_HIGHCONTRASTON: DWORD = 1;
 
 fn is_high_contrast() -> bool {
-    let mut hc = HIGHCONTRASTA {
-        cbSize: 0,
-        dwFlags: 0,
-        lpszDefaultScheme: std::ptr::null_mut(),
-    };
+  let mut hc = HIGHCONTRASTA {
+    cbSize: 0,
+    dwFlags: 0,
+    lpszDefaultScheme: std::ptr::null_mut(),
+  };
 
-    let ok = unsafe {
-        winuser::SystemParametersInfoA(
-            winuser::SPI_GETHIGHCONTRAST,
-            std::mem::size_of_val(&hc) as _,
-            &mut hc as *mut _ as _,
-            0,
-        )
-    };
+  let ok = unsafe {
+    winuser::SystemParametersInfoA(
+      winuser::SPI_GETHIGHCONTRAST,
+      std::mem::size_of_val(&hc) as _,
+      &mut hc as *mut _ as _,
+      0,
+    )
+  };
 
-    ok != FALSE && (HCF_HIGHCONTRASTON & hc.dwFlags) == 1
+  ok != FALSE && (HCF_HIGHCONTRASTON & hc.dwFlags) == 1
 }
 
 fn widestring(src: &'static str) -> Vec<u16> {
-    OsStr::new(src)
-        .encode_wide()
-        .chain(Some(0).into_iter())
-        .collect()
+  OsStr::new(src)
+    .encode_wide()
+    .chain(Some(0).into_iter())
+    .collect()
 }

src/platform_impl/windows/dpi.rs

@@ -3,114 +3,112 @@
 use std::sync::Once;
 
 use crate::platform_impl::platform::util::{
-    ENABLE_NON_CLIENT_DPI_SCALING, GET_DPI_FOR_MONITOR, GET_DPI_FOR_WINDOW, SET_PROCESS_DPI_AWARE,
-    SET_PROCESS_DPI_AWARENESS, SET_PROCESS_DPI_AWARENESS_CONTEXT,
+  ENABLE_NON_CLIENT_DPI_SCALING, GET_DPI_FOR_MONITOR, GET_DPI_FOR_WINDOW, SET_PROCESS_DPI_AWARE,
+  SET_PROCESS_DPI_AWARENESS, SET_PROCESS_DPI_AWARENESS_CONTEXT,
 };
 use winapi::{
-    shared::{
-        minwindef::FALSE,
-        windef::{DPI_AWARENESS_CONTEXT, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE, HMONITOR, HWND},
-        winerror::S_OK,
-    },
-    um::{
-        shellscalingapi::{MDT_EFFECTIVE_DPI, PROCESS_PER_MONITOR_DPI_AWARE},
-        wingdi::{GetDeviceCaps, LOGPIXELSX},
-        winuser::{self, MONITOR_DEFAULTTONEAREST},
-    },
+  shared::{
+    minwindef::FALSE,
+    windef::{DPI_AWARENESS_CONTEXT, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE, HMONITOR, HWND},
+    winerror::S_OK,
+  },
+  um::{
+    shellscalingapi::{MDT_EFFECTIVE_DPI, PROCESS_PER_MONITOR_DPI_AWARE},
+    wingdi::{GetDeviceCaps, LOGPIXELSX},
+    winuser::{self, MONITOR_DEFAULTTONEAREST},
+  },
 };
 
 const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2: DPI_AWARENESS_CONTEXT = -4isize as _;
 
 pub fn become_dpi_aware() {
-    static ENABLE_DPI_AWARENESS: Once = Once::new();
-    ENABLE_DPI_AWARENESS.call_once(|| {
-        unsafe {
-            if let Some(SetProcessDpiAwarenessContext) = *SET_PROCESS_DPI_AWARENESS_CONTEXT {
-                // We are on Windows 10 Anniversary Update (1607) or later.
-                if SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)
-                    == FALSE
-                {
-                    // V2 only works with Windows 10 Creators Update (1703). Try using the older
-                    // V1 if we can't set V2.
-                    SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE);
-                }
-            } else if let Some(SetProcessDpiAwareness) = *SET_PROCESS_DPI_AWARENESS {
-                // We are on Windows 8.1 or later.
-                SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
-            } else if let Some(SetProcessDPIAware) = *SET_PROCESS_DPI_AWARE {
-                // We are on Vista or later.
-                SetProcessDPIAware();
-            }
+  static ENABLE_DPI_AWARENESS: Once = Once::new();
+  ENABLE_DPI_AWARENESS.call_once(|| {
+    unsafe {
+      if let Some(SetProcessDpiAwarenessContext) = *SET_PROCESS_DPI_AWARENESS_CONTEXT {
+        // We are on Windows 10 Anniversary Update (1607) or later.
+        if SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) == FALSE {
+          // V2 only works with Windows 10 Creators Update (1703). Try using the older
+          // V1 if we can't set V2.
+          SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE);
         }
-    });
+      } else if let Some(SetProcessDpiAwareness) = *SET_PROCESS_DPI_AWARENESS {
+        // We are on Windows 8.1 or later.
+        SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
+      } else if let Some(SetProcessDPIAware) = *SET_PROCESS_DPI_AWARE {
+        // We are on Vista or later.
+        SetProcessDPIAware();
+      }
+    }
+  });
 }
 
 pub fn enable_non_client_dpi_scaling(hwnd: HWND) {
-    unsafe {
-        if let Some(EnableNonClientDpiScaling) = *ENABLE_NON_CLIENT_DPI_SCALING {
-            EnableNonClientDpiScaling(hwnd);
-        }
+  unsafe {
+    if let Some(EnableNonClientDpiScaling) = *ENABLE_NON_CLIENT_DPI_SCALING {
+      EnableNonClientDpiScaling(hwnd);
     }
+  }
 }
 
 pub fn get_monitor_dpi(hmonitor: HMONITOR) -> Option<u32> {
-    unsafe {
-        if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
-            // We are on Windows 8.1 or later.
-            let mut dpi_x = 0;
-            let mut dpi_y = 0;
-            if GetDpiForMonitor(hmonitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
-                // MSDN says that "the values of *dpiX and *dpiY are identical. You only need to
-                // record one of the values to determine the DPI and respond appropriately".
-                // https://msdn.microsoft.com/en-us/library/windows/desktop/dn280510(v=vs.85).aspx
-                return Some(dpi_x as u32);
-            }
-        }
+  unsafe {
+    if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
+      // We are on Windows 8.1 or later.
+      let mut dpi_x = 0;
+      let mut dpi_y = 0;
+      if GetDpiForMonitor(hmonitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
+        // MSDN says that "the values of *dpiX and *dpiY are identical. You only need to
+        // record one of the values to determine the DPI and respond appropriately".
+        // https://msdn.microsoft.com/en-us/library/windows/desktop/dn280510(v=vs.85).aspx
+        return Some(dpi_x as u32);
+      }
     }
-    None
+  }
+  None
 }
 
 pub const BASE_DPI: u32 = 96;
 pub fn dpi_to_scale_factor(dpi: u32) -> f64 {
-    dpi as f64 / BASE_DPI as f64
+  dpi as f64 / BASE_DPI as f64
 }
 
 pub unsafe fn hwnd_dpi(hwnd: HWND) -> u32 {
-    let hdc = winuser::GetDC(hwnd);
-    if hdc.is_null() {
-        panic!("[winit] `GetDC` returned null!");
+  let hdc = winuser::GetDC(hwnd);
+  if hdc.is_null() {
+    panic!("[winit] `GetDC` returned null!");
+  }
+  if let Some(GetDpiForWindow) = *GET_DPI_FOR_WINDOW {
+    // We are on Windows 10 Anniversary Update (1607) or later.
+    match GetDpiForWindow(hwnd) {
+      0 => BASE_DPI, // 0 is returned if hwnd is invalid
+      dpi => dpi as u32,
+    }
+  } else if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
+    // We are on Windows 8.1 or later.
+    let monitor = winuser::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
+    if monitor.is_null() {
+      return BASE_DPI;
     }
-    if let Some(GetDpiForWindow) = *GET_DPI_FOR_WINDOW {
-        // We are on Windows 10 Anniversary Update (1607) or later.
-        match GetDpiForWindow(hwnd) {
-            0 => BASE_DPI, // 0 is returned if hwnd is invalid
-            dpi => dpi as u32,
-        }
-    } else if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
-        // We are on Windows 8.1 or later.
-        let monitor = winuser::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
-        if monitor.is_null() {
-            return BASE_DPI;
-        }
 
-        let mut dpi_x = 0;
-        let mut dpi_y = 0;
-        if GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
-            dpi_x as u32
-        } else {
-            BASE_DPI
-        }
+    let mut dpi_x = 0;
+    let mut dpi_y = 0;
+    if GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
+      dpi_x as u32
     } else {
-        // We are on Vista or later.
-        if winuser::IsProcessDPIAware() != FALSE {
-            // If the process is DPI aware, then scaling must be handled by the application using
-            // this DPI value.
-            GetDeviceCaps(hdc, LOGPIXELSX) as u32
-        } else {
-            // If the process is DPI unaware, then scaling is performed by the OS; we thus return
-            // 96 (scale factor 1.0) to prevent the window from being re-scaled by both the
-            // application and the WM.
-            BASE_DPI
-        }
+      BASE_DPI
     }
+  } else {
+    // We are on Vista or later.
+    if winuser::IsProcessDPIAware() != FALSE {
+      // If the process is DPI aware, then scaling must be handled by the application using
+      // this DPI value.
+      GetDeviceCaps(hdc, LOGPIXELSX) as u32
+    } else {
+      // If the process is DPI unaware, then scaling is performed by the OS; we thus return
+      // 96 (scale factor 1.0) to prevent the window from being re-scaled by both the
+      // application and the WM.
+      BASE_DPI
+    }
+  }
 }

src/platform_impl/windows/drop_handler.rs

@@ -1,25 +1,25 @@
 use std::{
-    ffi::OsString,
-    os::windows::ffi::OsStringExt,
-    path::PathBuf,
-    ptr,
-    sync::atomic::{AtomicUsize, Ordering},
+  ffi::OsString,
+  os::windows::ffi::OsStringExt,
+  path::PathBuf,
+  ptr,
+  sync::atomic::{AtomicUsize, Ordering},
 };
 
 use winapi::{
-    ctypes::c_void,
-    shared::{
-        guiddef::REFIID,
-        minwindef::{DWORD, UINT, ULONG},
-        windef::{HWND, POINTL},
-        winerror::S_OK,
-    },
-    um::{
-        objidl::IDataObject,
-        oleidl::{IDropTarget, IDropTargetVtbl, DROPEFFECT_COPY, DROPEFFECT_NONE},
-        shellapi, unknwnbase,
-        winnt::HRESULT,
-    },
+  ctypes::c_void,
+  shared::{
+    guiddef::REFIID,
+    minwindef::{DWORD, UINT, ULONG},
+    windef::{HWND, POINTL},
+    winerror::S_OK,
+  },
+  um::{
+    objidl::IDataObject,
+    oleidl::{IDropTarget, IDropTargetVtbl, DROPEFFECT_COPY, DROPEFFECT_NONE},
+    shellapi, unknwnbase,
+    winnt::HRESULT,
+  },
 };
 
 use crate::platform_impl::platform::WindowId;
@@ -28,226 +28,226 @@ use crate::{event::Event, window::WindowId as SuperWindowId};
 
 #[repr(C)]
 pub struct FileDropHandlerData {
-    pub interface: IDropTarget,
-    refcount: AtomicUsize,
-    window: HWND,
-    send_event: Box<dyn Fn(Event<'static, ()>)>,
-    cursor_effect: DWORD,
-    hovered_is_valid: bool, /* If the currently hovered item is not valid there must not be any `HoveredFileCancelled` emitted */
+  pub interface: IDropTarget,
+  refcount: AtomicUsize,
+  window: HWND,
+  send_event: Box<dyn Fn(Event<'static, ()>)>,
+  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 {
-    pub data: *mut FileDropHandlerData,
+  pub data: *mut FileDropHandlerData,
 }
 
 #[allow(non_snake_case)]
 impl FileDropHandler {
-    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<'static, ()>)>) -> FileDropHandler {
-        let data = Box::new(FileDropHandlerData {
-            interface: IDropTarget {
-                lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl,
-            },
-            refcount: AtomicUsize::new(1),
-            window,
-            send_event,
-            cursor_effect: DROPEFFECT_NONE,
-            hovered_is_valid: false,
-        });
-        FileDropHandler {
-            data: Box::into_raw(data),
-        }
+  pub fn new(window: HWND, send_event: Box<dyn Fn(Event<'static, ()>)>) -> FileDropHandler {
+    let data = Box::new(FileDropHandlerData {
+      interface: IDropTarget {
+        lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl,
+      },
+      refcount: AtomicUsize::new(1),
+      window,
+      send_event,
+      cursor_effect: DROPEFFECT_NONE,
+      hovered_is_valid: false,
+    });
+    FileDropHandler {
+      data: Box::into_raw(data),
+    }
+  }
+
+  // Implement IUnknown
+  pub unsafe extern "system" fn QueryInterface(
+    _this: *mut unknwnbase::IUnknown,
+    _riid: REFIID,
+    _ppvObject: *mut *mut c_void,
+  ) -> HRESULT {
+    // This function doesn't appear to be required for an `IDropTarget`.
+    // An implementation would be nice however.
+    unimplemented!();
+  }
+
+  pub unsafe extern "system" fn AddRef(this: *mut unknwnbase::IUnknown) -> ULONG {
+    let drop_handler_data = Self::from_interface(this);
+    let count = drop_handler_data.refcount.fetch_add(1, Ordering::Release) + 1;
+    count as ULONG
+  }
+
+  pub unsafe extern "system" fn Release(this: *mut unknwnbase::IUnknown) -> ULONG {
+    let drop_handler = Self::from_interface(this);
+    let count = drop_handler.refcount.fetch_sub(1, Ordering::Release) - 1;
+    if count == 0 {
+      // Destroy the underlying data
+      Box::from_raw(drop_handler as *mut FileDropHandlerData);
+    }
+    count as ULONG
+  }
+
+  pub unsafe extern "system" fn DragEnter(
+    this: *mut IDropTarget,
+    pDataObj: *const IDataObject,
+    _grfKeyState: DWORD,
+    _pt: *const POINTL,
+    pdwEffect: *mut DWORD,
+  ) -> HRESULT {
+    use crate::event::WindowEvent::HoveredFile;
+    let drop_handler = Self::from_interface(this);
+    let hdrop = Self::iterate_filenames(pDataObj, |filename| {
+      drop_handler.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,
+    _grfKeyState: DWORD,
+    _pt: *const POINTL,
+    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 crate::event::WindowEvent::HoveredFileCancelled;
+    let drop_handler = Self::from_interface(this);
+    if drop_handler.hovered_is_valid {
+      drop_handler.send_event(Event::WindowEvent {
+        window_id: SuperWindowId(WindowId(drop_handler.window)),
+        event: HoveredFileCancelled,
+      });
     }
 
-    // Implement IUnknown
-    pub unsafe extern "system" fn QueryInterface(
-        _this: *mut unknwnbase::IUnknown,
-        _riid: REFIID,
-        _ppvObject: *mut *mut c_void,
-    ) -> HRESULT {
-        // This function doesn't appear to be required for an `IDropTarget`.
-        // An implementation would be nice however.
-        unimplemented!();
+    S_OK
+  }
+
+  pub unsafe extern "system" fn Drop(
+    this: *mut IDropTarget,
+    pDataObj: *const IDataObject,
+    _grfKeyState: DWORD,
+    _pt: *const POINTL,
+    _pdwEffect: *mut DWORD,
+  ) -> HRESULT {
+    use crate::event::WindowEvent::DroppedFile;
+    let drop_handler = Self::from_interface(this);
+    let hdrop = Self::iterate_filenames(pDataObj, |filename| {
+      drop_handler.send_event(Event::WindowEvent {
+        window_id: SuperWindowId(WindowId(drop_handler.window)),
+        event: DroppedFile(filename),
+      });
+    });
+    if let Some(hdrop) = hdrop {
+      shellapi::DragFinish(hdrop);
     }
 
-    pub unsafe extern "system" fn AddRef(this: *mut unknwnbase::IUnknown) -> ULONG {
-        let drop_handler_data = Self::from_interface(this);
-        let count = drop_handler_data.refcount.fetch_add(1, Ordering::Release) + 1;
-        count as ULONG
-    }
-
-    pub unsafe extern "system" fn Release(this: *mut unknwnbase::IUnknown) -> ULONG {
-        let drop_handler = Self::from_interface(this);
-        let count = drop_handler.refcount.fetch_sub(1, Ordering::Release) - 1;
-        if count == 0 {
-            // Destroy the underlying data
-            Box::from_raw(drop_handler as *mut FileDropHandlerData);
-        }
-        count as ULONG
-    }
-
-    pub unsafe extern "system" fn DragEnter(
-        this: *mut IDropTarget,
-        pDataObj: *const IDataObject,
-        _grfKeyState: DWORD,
-        _pt: *const POINTL,
-        pdwEffect: *mut DWORD,
-    ) -> HRESULT {
-        use crate::event::WindowEvent::HoveredFile;
-        let drop_handler = Self::from_interface(this);
-        let hdrop = Self::iterate_filenames(pDataObj, |filename| {
-            drop_handler.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,
-        _grfKeyState: DWORD,
-        _pt: *const POINTL,
-        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 crate::event::WindowEvent::HoveredFileCancelled;
-        let drop_handler = Self::from_interface(this);
-        if drop_handler.hovered_is_valid {
-            drop_handler.send_event(Event::WindowEvent {
-                window_id: SuperWindowId(WindowId(drop_handler.window)),
-                event: HoveredFileCancelled,
-            });
-        }
-
-        S_OK
-    }
-
-    pub unsafe extern "system" fn Drop(
-        this: *mut IDropTarget,
-        pDataObj: *const IDataObject,
-        _grfKeyState: DWORD,
-        _pt: *const POINTL,
-        _pdwEffect: *mut DWORD,
-    ) -> HRESULT {
-        use crate::event::WindowEvent::DroppedFile;
-        let drop_handler = Self::from_interface(this);
-        let hdrop = Self::iterate_filenames(pDataObj, |filename| {
-            drop_handler.send_event(Event::WindowEvent {
-                window_id: SuperWindowId(WindowId(drop_handler.window)),
-                event: DroppedFile(filename),
-            });
-        });
-        if let Some(hdrop) = hdrop {
-            shellapi::DragFinish(hdrop);
-        }
-
-        S_OK
-    }
-
-    unsafe fn from_interface<'a, InterfaceT>(this: *mut InterfaceT) -> &'a mut FileDropHandlerData {
-        &mut *(this as *mut _)
-    }
-
-    unsafe fn iterate_filenames<F>(
-        data_obj: *const IDataObject,
-        callback: F,
-    ) -> Option<shellapi::HDROP>
-    where
-        F: Fn(PathBuf),
-    {
-        use winapi::{
-            shared::{
-                winerror::{DV_E_FORMATETC, SUCCEEDED},
-                wtypes::{CLIPFORMAT, DVASPECT_CONTENT},
-            },
-            um::{
-                objidl::{FORMATETC, TYMED_HGLOBAL},
-                shellapi::DragQueryFileW,
-                winuser::CF_HDROP,
-            },
-        };
-
-        let mut drop_format = FORMATETC {
-            cfFormat: CF_HDROP as CLIPFORMAT,
-            ptd: ptr::null(),
-            dwAspect: DVASPECT_CONTENT,
-            lindex: -1,
-            tymed: TYMED_HGLOBAL,
-        };
-
-        let mut medium = std::mem::zeroed();
-        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;
-
-            // The second parameter (0xFFFFFFFF) instructs the function to return the item count
-            let item_count = DragQueryFileW(hdrop, 0xFFFFFFFF, ptr::null_mut(), 0);
-
-            for i in 0..item_count {
-                // Get the length of the path string NOT including the terminating null character.
-                // Previously, this was using a fixed size array of MAX_PATH length, but the
-                // Windows API allows longer paths under certain circumstances.
-                let character_count = DragQueryFileW(hdrop, i, ptr::null_mut(), 0) as usize;
-                let str_len = character_count + 1;
-
-                // Fill path_buf with the null-terminated file name
-                let mut path_buf = Vec::with_capacity(str_len);
-                DragQueryFileW(hdrop, i, path_buf.as_mut_ptr(), str_len as UINT);
-                path_buf.set_len(str_len);
-
-                callback(OsString::from_wide(&path_buf[0..character_count]).into());
-            }
-
-            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;
-        }
+    S_OK
+  }
+
+  unsafe fn from_interface<'a, InterfaceT>(this: *mut InterfaceT) -> &'a mut FileDropHandlerData {
+    &mut *(this as *mut _)
+  }
+
+  unsafe fn iterate_filenames<F>(
+    data_obj: *const IDataObject,
+    callback: F,
+  ) -> Option<shellapi::HDROP>
+  where
+    F: Fn(PathBuf),
+  {
+    use winapi::{
+      shared::{
+        winerror::{DV_E_FORMATETC, SUCCEEDED},
+        wtypes::{CLIPFORMAT, DVASPECT_CONTENT},
+      },
+      um::{
+        objidl::{FORMATETC, TYMED_HGLOBAL},
+        shellapi::DragQueryFileW,
+        winuser::CF_HDROP,
+      },
+    };
+
+    let mut drop_format = FORMATETC {
+      cfFormat: CF_HDROP as CLIPFORMAT,
+      ptd: ptr::null(),
+      dwAspect: DVASPECT_CONTENT,
+      lindex: -1,
+      tymed: TYMED_HGLOBAL,
+    };
+
+    let mut medium = std::mem::zeroed();
+    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;
+
+      // The second parameter (0xFFFFFFFF) instructs the function to return the item count
+      let item_count = DragQueryFileW(hdrop, 0xFFFFFFFF, ptr::null_mut(), 0);
+
+      for i in 0..item_count {
+        // Get the length of the path string NOT including the terminating null character.
+        // Previously, this was using a fixed size array of MAX_PATH length, but the
+        // Windows API allows longer paths under certain circumstances.
+        let character_count = DragQueryFileW(hdrop, i, ptr::null_mut(), 0) as usize;
+        let str_len = character_count + 1;
+
+        // Fill path_buf with the null-terminated file name
+        let mut path_buf = Vec::with_capacity(str_len);
+        DragQueryFileW(hdrop, i, path_buf.as_mut_ptr(), str_len as UINT);
+        path_buf.set_len(str_len);
+
+        callback(OsString::from_wide(&path_buf[0..character_count]).into());
+      }
+
+      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;
     }
+  }
 }
 
 impl FileDropHandlerData {
-    fn send_event(&self, event: Event<'static, ()>) {
-        (self.send_event)(event);
-    }
+  fn send_event(&self, event: Event<'static, ()>) {
+    (self.send_event)(event);
+  }
 }
 
 impl Drop for FileDropHandler {
-    fn drop(&mut self) {
-        unsafe {
-            FileDropHandler::Release(self.data as *mut unknwnbase::IUnknown);
-        }
+  fn drop(&mut self) {
+    unsafe {
+      FileDropHandler::Release(self.data as *mut unknwnbase::IUnknown);
     }
+  }
 }
 
 static DROP_TARGET_VTBL: IDropTargetVtbl = IDropTargetVtbl {
-    parent: unknwnbase::IUnknownVtbl {
-        QueryInterface: FileDropHandler::QueryInterface,
-        AddRef: FileDropHandler::AddRef,
-        Release: FileDropHandler::Release,
-    },
-    DragEnter: FileDropHandler::DragEnter,
-    DragOver: FileDropHandler::DragOver,
-    DragLeave: FileDropHandler::DragLeave,
-    Drop: FileDropHandler::Drop,
+  parent: unknwnbase::IUnknownVtbl {
+    QueryInterface: FileDropHandler::QueryInterface,
+    AddRef: FileDropHandler::AddRef,
+    Release: FileDropHandler::Release,
+  },
+  DragEnter: FileDropHandler::DragEnter,
+  DragOver: FileDropHandler::DragOver,
+  DragLeave: FileDropHandler::DragLeave,
+  Drop: FileDropHandler::Drop,
 };

src/platform_impl/windows/event.rs

@@ -1,39 +1,39 @@
 use std::{
-    char,
-    os::raw::c_int,
-    ptr,
-    sync::atomic::{AtomicBool, AtomicPtr, Ordering},
+  char,
+  os::raw::c_int,
+  ptr,
+  sync::atomic::{AtomicBool, AtomicPtr, Ordering},
 };
 
 use crate::event::{ModifiersState, ScanCode, VirtualKeyCode};
 
 use winapi::{
-    shared::minwindef::{HKL, HKL__, LPARAM, UINT, WPARAM},
-    um::winuser,
+  shared::minwindef::{HKL, HKL__, LPARAM, UINT, WPARAM},
+  um::winuser,
 };
 
 fn key_pressed(vkey: c_int) -> bool {
-    unsafe { (winuser::GetKeyState(vkey) & (1 << 15)) == (1 << 15) }
+  unsafe { (winuser::GetKeyState(vkey) & (1 << 15)) == (1 << 15) }
 }
 
 pub fn get_key_mods() -> ModifiersState {
-    let filter_out_altgr = layout_uses_altgr() && key_pressed(winuser::VK_RMENU);
+  let filter_out_altgr = layout_uses_altgr() && key_pressed(winuser::VK_RMENU);
 
-    let mut mods = ModifiersState::empty();
-    mods.set(ModifiersState::SHIFT, key_pressed(winuser::VK_SHIFT));
-    mods.set(
-        ModifiersState::CTRL,
-        key_pressed(winuser::VK_CONTROL) && !filter_out_altgr,
-    );
-    mods.set(
-        ModifiersState::ALT,
-        key_pressed(winuser::VK_MENU) && !filter_out_altgr,
-    );
-    mods.set(
-        ModifiersState::LOGO,
-        key_pressed(winuser::VK_LWIN) || key_pressed(winuser::VK_RWIN),
-    );
-    mods
+  let mut mods = ModifiersState::empty();
+  mods.set(ModifiersState::SHIFT, key_pressed(winuser::VK_SHIFT));
+  mods.set(
+    ModifiersState::CTRL,
+    key_pressed(winuser::VK_CONTROL) && !filter_out_altgr,
+  );
+  mods.set(
+    ModifiersState::ALT,
+    key_pressed(winuser::VK_MENU) && !filter_out_altgr,
+  );
+  mods.set(
+    ModifiersState::LOGO,
+    key_pressed(winuser::VK_LWIN) || key_pressed(winuser::VK_RWIN),
+  );
+  mods
 }
 
 bitflags! {
@@ -54,65 +54,65 @@ bitflags! {
 }
 
 impl ModifiersStateSide {
-    pub fn filter_out_altgr(&self) -> ModifiersStateSide {
-        match layout_uses_altgr() && self.contains(Self::RALT) {
-            false => *self,
-            true => *self & !(Self::LCTRL | Self::RCTRL | Self::LALT | Self::RALT),
-        }
+  pub fn filter_out_altgr(&self) -> ModifiersStateSide {
+    match layout_uses_altgr() && self.contains(Self::RALT) {
+      false => *self,
+      true => *self & !(Self::LCTRL | Self::RCTRL | Self::LALT | Self::RALT),
     }
+  }
 }
 
 impl From<ModifiersStateSide> for ModifiersState {
-    fn from(side: ModifiersStateSide) -> Self {
-        let mut state = ModifiersState::default();
-        state.set(
-            Self::SHIFT,
-            side.intersects(ModifiersStateSide::LSHIFT | ModifiersStateSide::RSHIFT),
-        );
-        state.set(
-            Self::CTRL,
-            side.intersects(ModifiersStateSide::LCTRL | ModifiersStateSide::RCTRL),
-        );
-        state.set(
-            Self::ALT,
-            side.intersects(ModifiersStateSide::LALT | ModifiersStateSide::RALT),
-        );
-        state.set(
-            Self::LOGO,
-            side.intersects(ModifiersStateSide::LLOGO | ModifiersStateSide::RLOGO),
-        );
-        state
-    }
+  fn from(side: ModifiersStateSide) -> Self {
+    let mut state = ModifiersState::default();
+    state.set(
+      Self::SHIFT,
+      side.intersects(ModifiersStateSide::LSHIFT | ModifiersStateSide::RSHIFT),
+    );
+    state.set(
+      Self::CTRL,
+      side.intersects(ModifiersStateSide::LCTRL | ModifiersStateSide::RCTRL),
+    );
+    state.set(
+      Self::ALT,
+      side.intersects(ModifiersStateSide::LALT | ModifiersStateSide::RALT),
+    );
+    state.set(
+      Self::LOGO,
+      side.intersects(ModifiersStateSide::LLOGO | ModifiersStateSide::RLOGO),
+    );
+    state
+  }
 }
 
 pub fn get_pressed_keys() -> impl Iterator<Item = c_int> {
-    let mut keyboard_state = vec![0u8; 256];
-    unsafe { winuser::GetKeyboardState(keyboard_state.as_mut_ptr()) };
-    keyboard_state
-        .into_iter()
-        .enumerate()
-        .filter(|(_, p)| (*p & (1 << 7)) != 0) // whether or not a key is pressed is communicated via the high-order bit
-        .map(|(i, _)| i as c_int)
+  let mut keyboard_state = vec![0u8; 256];
+  unsafe { winuser::GetKeyboardState(keyboard_state.as_mut_ptr()) };
+  keyboard_state
+    .into_iter()
+    .enumerate()
+    .filter(|(_, p)| (*p & (1 << 7)) != 0) // whether or not a key is pressed is communicated via the high-order bit
+    .map(|(i, _)| i as c_int)
 }
 
 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.iter().cloned())
-            .next()
-            .and_then(|c| c.ok())
-    } else {
-        None
-    }
+  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.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.
@@ -125,293 +125,292 @@ unsafe fn get_char(keyboard_state: &[u8; 256], v_key: u32, hkl: HKL) -> Option<c
 ///
 /// [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);
+  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);
+    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
+    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 {
-        //winuser::VK_LBUTTON => Some(VirtualKeyCode::Lbutton),
-        //winuser::VK_RBUTTON => Some(VirtualKeyCode::Rbutton),
-        //winuser::VK_CANCEL => Some(VirtualKeyCode::Cancel),
-        //winuser::VK_MBUTTON => Some(VirtualKeyCode::Mbutton),
-        //winuser::VK_XBUTTON1 => Some(VirtualKeyCode::Xbutton1),
-        //winuser::VK_XBUTTON2 => Some(VirtualKeyCode::Xbutton2),
-        winuser::VK_BACK => Some(VirtualKeyCode::Back),
-        winuser::VK_TAB => Some(VirtualKeyCode::Tab),
-        //winuser::VK_CLEAR => Some(VirtualKeyCode::Clear),
-        winuser::VK_RETURN => Some(VirtualKeyCode::Return),
-        winuser::VK_LSHIFT => Some(VirtualKeyCode::LShift),
-        winuser::VK_RSHIFT => Some(VirtualKeyCode::RShift),
-        winuser::VK_LCONTROL => Some(VirtualKeyCode::LControl),
-        winuser::VK_RCONTROL => Some(VirtualKeyCode::RControl),
-        winuser::VK_LMENU => Some(VirtualKeyCode::LAlt),
-        winuser::VK_RMENU => Some(VirtualKeyCode::RAlt),
-        winuser::VK_PAUSE => Some(VirtualKeyCode::Pause),
-        winuser::VK_CAPITAL => Some(VirtualKeyCode::Capital),
-        winuser::VK_KANA => Some(VirtualKeyCode::Kana),
-        //winuser::VK_HANGUEL => Some(VirtualKeyCode::Hanguel),
-        //winuser::VK_HANGUL => Some(VirtualKeyCode::Hangul),
-        //winuser::VK_JUNJA => Some(VirtualKeyCode::Junja),
-        //winuser::VK_FINAL => Some(VirtualKeyCode::Final),
-        //winuser::VK_HANJA => Some(VirtualKeyCode::Hanja),
-        winuser::VK_KANJI => Some(VirtualKeyCode::Kanji),
-        winuser::VK_ESCAPE => Some(VirtualKeyCode::Escape),
-        winuser::VK_CONVERT => Some(VirtualKeyCode::Convert),
-        winuser::VK_NONCONVERT => Some(VirtualKeyCode::NoConvert),
-        //winuser::VK_ACCEPT => Some(VirtualKeyCode::Accept),
-        //winuser::VK_MODECHANGE => Some(VirtualKeyCode::Modechange),
-        winuser::VK_SPACE => Some(VirtualKeyCode::Space),
-        winuser::VK_PRIOR => Some(VirtualKeyCode::PageUp),
-        winuser::VK_NEXT => Some(VirtualKeyCode::PageDown),
-        winuser::VK_END => Some(VirtualKeyCode::End),
-        winuser::VK_HOME => Some(VirtualKeyCode::Home),
-        winuser::VK_LEFT => Some(VirtualKeyCode::Left),
-        winuser::VK_UP => Some(VirtualKeyCode::Up),
-        winuser::VK_RIGHT => Some(VirtualKeyCode::Right),
-        winuser::VK_DOWN => Some(VirtualKeyCode::Down),
-        //winuser::VK_SELECT => Some(VirtualKeyCode::Select),
-        //winuser::VK_PRINT => Some(VirtualKeyCode::Print),
-        //winuser::VK_EXECUTE => Some(VirtualKeyCode::Execute),
-        winuser::VK_SNAPSHOT => Some(VirtualKeyCode::Snapshot),
-        winuser::VK_INSERT => Some(VirtualKeyCode::Insert),
-        winuser::VK_DELETE => Some(VirtualKeyCode::Delete),
-        //winuser::VK_HELP => Some(VirtualKeyCode::Help),
-        0x30 => Some(VirtualKeyCode::Key0),
-        0x31 => Some(VirtualKeyCode::Key1),
-        0x32 => Some(VirtualKeyCode::Key2),
-        0x33 => Some(VirtualKeyCode::Key3),
-        0x34 => Some(VirtualKeyCode::Key4),
-        0x35 => Some(VirtualKeyCode::Key5),
-        0x36 => Some(VirtualKeyCode::Key6),
-        0x37 => Some(VirtualKeyCode::Key7),
-        0x38 => Some(VirtualKeyCode::Key8),
-        0x39 => Some(VirtualKeyCode::Key9),
-        0x41 => Some(VirtualKeyCode::A),
-        0x42 => Some(VirtualKeyCode::B),
-        0x43 => Some(VirtualKeyCode::C),
-        0x44 => Some(VirtualKeyCode::D),
-        0x45 => Some(VirtualKeyCode::E),
-        0x46 => Some(VirtualKeyCode::F),
-        0x47 => Some(VirtualKeyCode::G),
-        0x48 => Some(VirtualKeyCode::H),
-        0x49 => Some(VirtualKeyCode::I),
-        0x4A => Some(VirtualKeyCode::J),
-        0x4B => Some(VirtualKeyCode::K),
-        0x4C => Some(VirtualKeyCode::L),
-        0x4D => Some(VirtualKeyCode::M),
-        0x4E => Some(VirtualKeyCode::N),
-        0x4F => Some(VirtualKeyCode::O),
-        0x50 => Some(VirtualKeyCode::P),
-        0x51 => Some(VirtualKeyCode::Q),
-        0x52 => Some(VirtualKeyCode::R),
-        0x53 => Some(VirtualKeyCode::S),
-        0x54 => Some(VirtualKeyCode::T),
-        0x55 => Some(VirtualKeyCode::U),
-        0x56 => Some(VirtualKeyCode::V),
-        0x57 => Some(VirtualKeyCode::W),
-        0x58 => Some(VirtualKeyCode::X),
-        0x59 => Some(VirtualKeyCode::Y),
-        0x5A => Some(VirtualKeyCode::Z),
-        winuser::VK_LWIN => Some(VirtualKeyCode::LWin),
-        winuser::VK_RWIN => Some(VirtualKeyCode::RWin),
-        winuser::VK_APPS => Some(VirtualKeyCode::Apps),
-        winuser::VK_SLEEP => Some(VirtualKeyCode::Sleep),
-        winuser::VK_NUMPAD0 => Some(VirtualKeyCode::Numpad0),
-        winuser::VK_NUMPAD1 => Some(VirtualKeyCode::Numpad1),
-        winuser::VK_NUMPAD2 => Some(VirtualKeyCode::Numpad2),
-        winuser::VK_NUMPAD3 => Some(VirtualKeyCode::Numpad3),
-        winuser::VK_NUMPAD4 => Some(VirtualKeyCode::Numpad4),
-        winuser::VK_NUMPAD5 => Some(VirtualKeyCode::Numpad5),
-        winuser::VK_NUMPAD6 => Some(VirtualKeyCode::Numpad6),
-        winuser::VK_NUMPAD7 => Some(VirtualKeyCode::Numpad7),
-        winuser::VK_NUMPAD8 => Some(VirtualKeyCode::Numpad8),
-        winuser::VK_NUMPAD9 => Some(VirtualKeyCode::Numpad9),
-        winuser::VK_MULTIPLY => Some(VirtualKeyCode::NumpadMultiply),
-        winuser::VK_ADD => Some(VirtualKeyCode::NumpadAdd),
-        //winuser::VK_SEPARATOR => Some(VirtualKeyCode::Separator),
-        winuser::VK_SUBTRACT => Some(VirtualKeyCode::NumpadSubtract),
-        winuser::VK_DECIMAL => Some(VirtualKeyCode::NumpadDecimal),
-        winuser::VK_DIVIDE => Some(VirtualKeyCode::NumpadDivide),
-        winuser::VK_F1 => Some(VirtualKeyCode::F1),
-        winuser::VK_F2 => Some(VirtualKeyCode::F2),
-        winuser::VK_F3 => Some(VirtualKeyCode::F3),
-        winuser::VK_F4 => Some(VirtualKeyCode::F4),
-        winuser::VK_F5 => Some(VirtualKeyCode::F5),
-        winuser::VK_F6 => Some(VirtualKeyCode::F6),
-        winuser::VK_F7 => Some(VirtualKeyCode::F7),
-        winuser::VK_F8 => Some(VirtualKeyCode::F8),
-        winuser::VK_F9 => Some(VirtualKeyCode::F9),
-        winuser::VK_F10 => Some(VirtualKeyCode::F10),
-        winuser::VK_F11 => Some(VirtualKeyCode::F11),
-        winuser::VK_F12 => Some(VirtualKeyCode::F12),
-        winuser::VK_F13 => Some(VirtualKeyCode::F13),
-        winuser::VK_F14 => Some(VirtualKeyCode::F14),
-        winuser::VK_F15 => Some(VirtualKeyCode::F15),
-        winuser::VK_F16 => Some(VirtualKeyCode::F16),
-        winuser::VK_F17 => Some(VirtualKeyCode::F17),
-        winuser::VK_F18 => Some(VirtualKeyCode::F18),
-        winuser::VK_F19 => Some(VirtualKeyCode::F19),
-        winuser::VK_F20 => Some(VirtualKeyCode::F20),
-        winuser::VK_F21 => Some(VirtualKeyCode::F21),
-        winuser::VK_F22 => Some(VirtualKeyCode::F22),
-        winuser::VK_F23 => Some(VirtualKeyCode::F23),
-        winuser::VK_F24 => Some(VirtualKeyCode::F24),
-        winuser::VK_NUMLOCK => Some(VirtualKeyCode::Numlock),
-        winuser::VK_SCROLL => Some(VirtualKeyCode::Scroll),
-        winuser::VK_BROWSER_BACK => Some(VirtualKeyCode::NavigateBackward),
-        winuser::VK_BROWSER_FORWARD => Some(VirtualKeyCode::NavigateForward),
-        winuser::VK_BROWSER_REFRESH => Some(VirtualKeyCode::WebRefresh),
-        winuser::VK_BROWSER_STOP => Some(VirtualKeyCode::WebStop),
-        winuser::VK_BROWSER_SEARCH => Some(VirtualKeyCode::WebSearch),
-        winuser::VK_BROWSER_FAVORITES => Some(VirtualKeyCode::WebFavorites),
-        winuser::VK_BROWSER_HOME => Some(VirtualKeyCode::WebHome),
-        winuser::VK_VOLUME_MUTE => Some(VirtualKeyCode::Mute),
-        winuser::VK_VOLUME_DOWN => Some(VirtualKeyCode::VolumeDown),
-        winuser::VK_VOLUME_UP => Some(VirtualKeyCode::VolumeUp),
-        winuser::VK_MEDIA_NEXT_TRACK => Some(VirtualKeyCode::NextTrack),
-        winuser::VK_MEDIA_PREV_TRACK => Some(VirtualKeyCode::PrevTrack),
-        winuser::VK_MEDIA_STOP => Some(VirtualKeyCode::MediaStop),
-        winuser::VK_MEDIA_PLAY_PAUSE => Some(VirtualKeyCode::PlayPause),
-        winuser::VK_LAUNCH_MAIL => Some(VirtualKeyCode::Mail),
-        winuser::VK_LAUNCH_MEDIA_SELECT => Some(VirtualKeyCode::MediaSelect),
-        /*winuser::VK_LAUNCH_APP1 => Some(VirtualKeyCode::Launch_app1),
-        winuser::VK_LAUNCH_APP2 => Some(VirtualKeyCode::Launch_app2),*/
-        winuser::VK_OEM_PLUS => Some(VirtualKeyCode::Equals),
-        winuser::VK_OEM_COMMA => Some(VirtualKeyCode::Comma),
-        winuser::VK_OEM_MINUS => Some(VirtualKeyCode::Minus),
-        winuser::VK_OEM_PERIOD => Some(VirtualKeyCode::Period),
-        winuser::VK_OEM_1 => map_text_keys(vkey),
-        winuser::VK_OEM_2 => map_text_keys(vkey),
-        winuser::VK_OEM_3 => map_text_keys(vkey),
-        winuser::VK_OEM_4 => map_text_keys(vkey),
-        winuser::VK_OEM_5 => map_text_keys(vkey),
-        winuser::VK_OEM_6 => map_text_keys(vkey),
-        winuser::VK_OEM_7 => map_text_keys(vkey),
-        /* winuser::VK_OEM_8 => Some(VirtualKeyCode::Oem_8), */
-        winuser::VK_OEM_102 => Some(VirtualKeyCode::OEM102),
-        /*winuser::VK_PROCESSKEY => Some(VirtualKeyCode::Processkey),
-        winuser::VK_PACKET => Some(VirtualKeyCode::Packet),
-        winuser::VK_ATTN => Some(VirtualKeyCode::Attn),
-        winuser::VK_CRSEL => Some(VirtualKeyCode::Crsel),
-        winuser::VK_EXSEL => Some(VirtualKeyCode::Exsel),
-        winuser::VK_EREOF => Some(VirtualKeyCode::Ereof),
-        winuser::VK_PLAY => Some(VirtualKeyCode::Play),
-        winuser::VK_ZOOM => Some(VirtualKeyCode::Zoom),
-        winuser::VK_NONAME => Some(VirtualKeyCode::Noname),
-        winuser::VK_PA1 => Some(VirtualKeyCode::Pa1),
-        winuser::VK_OEM_CLEAR => Some(VirtualKeyCode::Oem_clear),*/
-        _ => None,
-    }
+  // VK_* codes are documented here https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+  match vkey {
+    //winuser::VK_LBUTTON => Some(VirtualKeyCode::Lbutton),
+    //winuser::VK_RBUTTON => Some(VirtualKeyCode::Rbutton),
+    //winuser::VK_CANCEL => Some(VirtualKeyCode::Cancel),
+    //winuser::VK_MBUTTON => Some(VirtualKeyCode::Mbutton),
+    //winuser::VK_XBUTTON1 => Some(VirtualKeyCode::Xbutton1),
+    //winuser::VK_XBUTTON2 => Some(VirtualKeyCode::Xbutton2),
+    winuser::VK_BACK => Some(VirtualKeyCode::Back),
+    winuser::VK_TAB => Some(VirtualKeyCode::Tab),
+    //winuser::VK_CLEAR => Some(VirtualKeyCode::Clear),
+    winuser::VK_RETURN => Some(VirtualKeyCode::Return),
+    winuser::VK_LSHIFT => Some(VirtualKeyCode::LShift),
+    winuser::VK_RSHIFT => Some(VirtualKeyCode::RShift),
+    winuser::VK_LCONTROL => Some(VirtualKeyCode::LControl),
+    winuser::VK_RCONTROL => Some(VirtualKeyCode::RControl),
+    winuser::VK_LMENU => Some(VirtualKeyCode::LAlt),
+    winuser::VK_RMENU => Some(VirtualKeyCode::RAlt),
+    winuser::VK_PAUSE => Some(VirtualKeyCode::Pause),
+    winuser::VK_CAPITAL => Some(VirtualKeyCode::Capital),
+    winuser::VK_KANA => Some(VirtualKeyCode::Kana),
+    //winuser::VK_HANGUEL => Some(VirtualKeyCode::Hanguel),
+    //winuser::VK_HANGUL => Some(VirtualKeyCode::Hangul),
+    //winuser::VK_JUNJA => Some(VirtualKeyCode::Junja),
+    //winuser::VK_FINAL => Some(VirtualKeyCode::Final),
+    //winuser::VK_HANJA => Some(VirtualKeyCode::Hanja),
+    winuser::VK_KANJI => Some(VirtualKeyCode::Kanji),
+    winuser::VK_ESCAPE => Some(VirtualKeyCode::Escape),
+    winuser::VK_CONVERT => Some(VirtualKeyCode::Convert),
+    winuser::VK_NONCONVERT => Some(VirtualKeyCode::NoConvert),
+    //winuser::VK_ACCEPT => Some(VirtualKeyCode::Accept),
+    //winuser::VK_MODECHANGE => Some(VirtualKeyCode::Modechange),
+    winuser::VK_SPACE => Some(VirtualKeyCode::Space),
+    winuser::VK_PRIOR => Some(VirtualKeyCode::PageUp),
+    winuser::VK_NEXT => Some(VirtualKeyCode::PageDown),
+    winuser::VK_END => Some(VirtualKeyCode::End),
+    winuser::VK_HOME => Some(VirtualKeyCode::Home),
+    winuser::VK_LEFT => Some(VirtualKeyCode::Left),
+    winuser::VK_UP => Some(VirtualKeyCode::Up),
+    winuser::VK_RIGHT => Some(VirtualKeyCode::Right),
+    winuser::VK_DOWN => Some(VirtualKeyCode::Down),
+    //winuser::VK_SELECT => Some(VirtualKeyCode::Select),
+    //winuser::VK_PRINT => Some(VirtualKeyCode::Print),
+    //winuser::VK_EXECUTE => Some(VirtualKeyCode::Execute),
+    winuser::VK_SNAPSHOT => Some(VirtualKeyCode::Snapshot),
+    winuser::VK_INSERT => Some(VirtualKeyCode::Insert),
+    winuser::VK_DELETE => Some(VirtualKeyCode::Delete),
+    //winuser::VK_HELP => Some(VirtualKeyCode::Help),
+    0x30 => Some(VirtualKeyCode::Key0),
+    0x31 => Some(VirtualKeyCode::Key1),
+    0x32 => Some(VirtualKeyCode::Key2),
+    0x33 => Some(VirtualKeyCode::Key3),
+    0x34 => Some(VirtualKeyCode::Key4),
+    0x35 => Some(VirtualKeyCode::Key5),
+    0x36 => Some(VirtualKeyCode::Key6),
+    0x37 => Some(VirtualKeyCode::Key7),
+    0x38 => Some(VirtualKeyCode::Key8),
+    0x39 => Some(VirtualKeyCode::Key9),
+    0x41 => Some(VirtualKeyCode::A),
+    0x42 => Some(VirtualKeyCode::B),
+    0x43 => Some(VirtualKeyCode::C),
+    0x44 => Some(VirtualKeyCode::D),
+    0x45 => Some(VirtualKeyCode::E),
+    0x46 => Some(VirtualKeyCode::F),
+    0x47 => Some(VirtualKeyCode::G),
+    0x48 => Some(VirtualKeyCode::H),
+    0x49 => Some(VirtualKeyCode::I),
+    0x4A => Some(VirtualKeyCode::J),
+    0x4B => Some(VirtualKeyCode::K),
+    0x4C => Some(VirtualKeyCode::L),
+    0x4D => Some(VirtualKeyCode::M),
+    0x4E => Some(VirtualKeyCode::N),
+    0x4F => Some(VirtualKeyCode::O),
+    0x50 => Some(VirtualKeyCode::P),
+    0x51 => Some(VirtualKeyCode::Q),
+    0x52 => Some(VirtualKeyCode::R),
+    0x53 => Some(VirtualKeyCode::S),
+    0x54 => Some(VirtualKeyCode::T),
+    0x55 => Some(VirtualKeyCode::U),
+    0x56 => Some(VirtualKeyCode::V),
+    0x57 => Some(VirtualKeyCode::W),
+    0x58 => Some(VirtualKeyCode::X),
+    0x59 => Some(VirtualKeyCode::Y),
+    0x5A => Some(VirtualKeyCode::Z),
+    winuser::VK_LWIN => Some(VirtualKeyCode::LWin),
+    winuser::VK_RWIN => Some(VirtualKeyCode::RWin),
+    winuser::VK_APPS => Some(VirtualKeyCode::Apps),
+    winuser::VK_SLEEP => Some(VirtualKeyCode::Sleep),
+    winuser::VK_NUMPAD0 => Some(VirtualKeyCode::Numpad0),
+    winuser::VK_NUMPAD1 => Some(VirtualKeyCode::Numpad1),
+    winuser::VK_NUMPAD2 => Some(VirtualKeyCode::Numpad2),
+    winuser::VK_NUMPAD3 => Some(VirtualKeyCode::Numpad3),
+    winuser::VK_NUMPAD4 => Some(VirtualKeyCode::Numpad4),
+    winuser::VK_NUMPAD5 => Some(VirtualKeyCode::Numpad5),
+    winuser::VK_NUMPAD6 => Some(VirtualKeyCode::Numpad6),
+    winuser::VK_NUMPAD7 => Some(VirtualKeyCode::Numpad7),
+    winuser::VK_NUMPAD8 => Some(VirtualKeyCode::Numpad8),
+    winuser::VK_NUMPAD9 => Some(VirtualKeyCode::Numpad9),
+    winuser::VK_MULTIPLY => Some(VirtualKeyCode::NumpadMultiply),
+    winuser::VK_ADD => Some(VirtualKeyCode::NumpadAdd),
+    //winuser::VK_SEPARATOR => Some(VirtualKeyCode::Separator),
+    winuser::VK_SUBTRACT => Some(VirtualKeyCode::NumpadSubtract),
+    winuser::VK_DECIMAL => Some(VirtualKeyCode::NumpadDecimal),
+    winuser::VK_DIVIDE => Some(VirtualKeyCode::NumpadDivide),
+    winuser::VK_F1 => Some(VirtualKeyCode::F1),
+    winuser::VK_F2 => Some(VirtualKeyCode::F2),
+    winuser::VK_F3 => Some(VirtualKeyCode::F3),
+    winuser::VK_F4 => Some(VirtualKeyCode::F4),
+    winuser::VK_F5 => Some(VirtualKeyCode::F5),
+    winuser::VK_F6 => Some(VirtualKeyCode::F6),
+    winuser::VK_F7 => Some(VirtualKeyCode::F7),
+    winuser::VK_F8 => Some(VirtualKeyCode::F8),
+    winuser::VK_F9 => Some(VirtualKeyCode::F9),
+    winuser::VK_F10 => Some(VirtualKeyCode::F10),
+    winuser::VK_F11 => Some(VirtualKeyCode::F11),
+    winuser::VK_F12 => Some(VirtualKeyCode::F12),
+    winuser::VK_F13 => Some(VirtualKeyCode::F13),
+    winuser::VK_F14 => Some(VirtualKeyCode::F14),
+    winuser::VK_F15 => Some(VirtualKeyCode::F15),
+    winuser::VK_F16 => Some(VirtualKeyCode::F16),
+    winuser::VK_F17 => Some(VirtualKeyCode::F17),
+    winuser::VK_F18 => Some(VirtualKeyCode::F18),
+    winuser::VK_F19 => Some(VirtualKeyCode::F19),
+    winuser::VK_F20 => Some(VirtualKeyCode::F20),
+    winuser::VK_F21 => Some(VirtualKeyCode::F21),
+    winuser::VK_F22 => Some(VirtualKeyCode::F22),
+    winuser::VK_F23 => Some(VirtualKeyCode::F23),
+    winuser::VK_F24 => Some(VirtualKeyCode::F24),
+    winuser::VK_NUMLOCK => Some(VirtualKeyCode::Numlock),
+    winuser::VK_SCROLL => Some(VirtualKeyCode::Scroll),
+    winuser::VK_BROWSER_BACK => Some(VirtualKeyCode::NavigateBackward),
+    winuser::VK_BROWSER_FORWARD => Some(VirtualKeyCode::NavigateForward),
+    winuser::VK_BROWSER_REFRESH => Some(VirtualKeyCode::WebRefresh),
+    winuser::VK_BROWSER_STOP => Some(VirtualKeyCode::WebStop),
+    winuser::VK_BROWSER_SEARCH => Some(VirtualKeyCode::WebSearch),
+    winuser::VK_BROWSER_FAVORITES => Some(VirtualKeyCode::WebFavorites),
+    winuser::VK_BROWSER_HOME => Some(VirtualKeyCode::WebHome),
+    winuser::VK_VOLUME_MUTE => Some(VirtualKeyCode::Mute),
+    winuser::VK_VOLUME_DOWN => Some(VirtualKeyCode::VolumeDown),
+    winuser::VK_VOLUME_UP => Some(VirtualKeyCode::VolumeUp),
+    winuser::VK_MEDIA_NEXT_TRACK => Some(VirtualKeyCode::NextTrack),
+    winuser::VK_MEDIA_PREV_TRACK => Some(VirtualKeyCode::PrevTrack),
+    winuser::VK_MEDIA_STOP => Some(VirtualKeyCode::MediaStop),
+    winuser::VK_MEDIA_PLAY_PAUSE => Some(VirtualKeyCode::PlayPause),
+    winuser::VK_LAUNCH_MAIL => Some(VirtualKeyCode::Mail),
+    winuser::VK_LAUNCH_MEDIA_SELECT => Some(VirtualKeyCode::MediaSelect),
+    /*winuser::VK_LAUNCH_APP1 => Some(VirtualKeyCode::Launch_app1),
+    winuser::VK_LAUNCH_APP2 => Some(VirtualKeyCode::Launch_app2),*/
+    winuser::VK_OEM_PLUS => Some(VirtualKeyCode::Equals),
+    winuser::VK_OEM_COMMA => Some(VirtualKeyCode::Comma),
+    winuser::VK_OEM_MINUS => Some(VirtualKeyCode::Minus),
+    winuser::VK_OEM_PERIOD => Some(VirtualKeyCode::Period),
+    winuser::VK_OEM_1 => map_text_keys(vkey),
+    winuser::VK_OEM_2 => map_text_keys(vkey),
+    winuser::VK_OEM_3 => map_text_keys(vkey),
+    winuser::VK_OEM_4 => map_text_keys(vkey),
+    winuser::VK_OEM_5 => map_text_keys(vkey),
+    winuser::VK_OEM_6 => map_text_keys(vkey),
+    winuser::VK_OEM_7 => map_text_keys(vkey),
+    /* winuser::VK_OEM_8 => Some(VirtualKeyCode::Oem_8), */
+    winuser::VK_OEM_102 => Some(VirtualKeyCode::OEM102),
+    /*winuser::VK_PROCESSKEY => Some(VirtualKeyCode::Processkey),
+    winuser::VK_PACKET => Some(VirtualKeyCode::Packet),
+    winuser::VK_ATTN => Some(VirtualKeyCode::Attn),
+    winuser::VK_CRSEL => Some(VirtualKeyCode::Crsel),
+    winuser::VK_EXSEL => Some(VirtualKeyCode::Exsel),
+    winuser::VK_EREOF => Some(VirtualKeyCode::Ereof),
+    winuser::VK_PLAY => Some(VirtualKeyCode::Play),
+    winuser::VK_ZOOM => Some(VirtualKeyCode::Zoom),
+    winuser::VK_NONAME => Some(VirtualKeyCode::Noname),
+    winuser::VK_PA1 => Some(VirtualKeyCode::Pa1),
+    winuser::VK_OEM_CLEAR => Some(VirtualKeyCode::Oem_clear),*/
+    _ => None,
+  }
 }
 
 pub fn handle_extended_keys(
-    vkey: c_int,
-    mut scancode: UINT,
-    extended: bool,
+  vkey: c_int,
+  mut scancode: UINT,
+  extended: bool,
 ) -> Option<(c_int, UINT)> {
-    // Welcome to hell https://blog.molecular-matters.com/2011/09/05/properly-handling-keyboard-input/
-    scancode = if extended { 0xE000 } else { 0x0000 } | scancode;
-    let vkey = match vkey {
-        winuser::VK_SHIFT => unsafe {
-            winuser::MapVirtualKeyA(scancode, winuser::MAPVK_VSC_TO_VK_EX) as _
-        },
-        winuser::VK_CONTROL => {
-            if extended {
-                winuser::VK_RCONTROL
-            } else {
-                winuser::VK_LCONTROL
-            }
+  // Welcome to hell https://blog.molecular-matters.com/2011/09/05/properly-handling-keyboard-input/
+  scancode = if extended { 0xE000 } else { 0x0000 } | scancode;
+  let vkey = match vkey {
+    winuser::VK_SHIFT => unsafe {
+      winuser::MapVirtualKeyA(scancode, winuser::MAPVK_VSC_TO_VK_EX) as _
+    },
+    winuser::VK_CONTROL => {
+      if extended {
+        winuser::VK_RCONTROL
+      } else {
+        winuser::VK_LCONTROL
+      }
+    }
+    winuser::VK_MENU => {
+      if extended {
+        winuser::VK_RMENU
+      } else {
+        winuser::VK_LMENU
+      }
+    }
+    _ => {
+      match scancode {
+        // When VK_PAUSE is pressed it emits a LeftControl + NumLock scancode event sequence, but reports VK_PAUSE
+        // as the virtual key on both events, or VK_PAUSE on the first event or 0xFF when using raw input.
+        // Don't emit anything for the LeftControl event in the pair...
+        0xE01D if vkey == winuser::VK_PAUSE => return None,
+        // ...and emit the Pause event for the second event in the pair.
+        0x45 if vkey == winuser::VK_PAUSE || vkey == 0xFF as _ => {
+          scancode = 0xE059;
+          winuser::VK_PAUSE
         }
-        winuser::VK_MENU => {
-            if extended {
-                winuser::VK_RMENU
-            } else {
-                winuser::VK_LMENU
-            }
+        // VK_PAUSE has an incorrect vkey value when used with modifiers. VK_PAUSE also reports a different
+        // scancode when used with modifiers than when used without
+        0xE046 => {
+          scancode = 0xE059;
+          winuser::VK_PAUSE
         }
-        _ => {
-            match scancode {
-                // When VK_PAUSE is pressed it emits a LeftControl + NumLock scancode event sequence, but reports VK_PAUSE
-                // as the virtual key on both events, or VK_PAUSE on the first event or 0xFF when using raw input.
-                // Don't emit anything for the LeftControl event in the pair...
-                0xE01D if vkey == winuser::VK_PAUSE => return None,
-                // ...and emit the Pause event for the second event in the pair.
-                0x45 if vkey == winuser::VK_PAUSE || vkey == 0xFF as _ => {
-                    scancode = 0xE059;
-                    winuser::VK_PAUSE
-                }
-                // VK_PAUSE has an incorrect vkey value when used with modifiers. VK_PAUSE also reports a different
-                // scancode when used with modifiers than when used without
-                0xE046 => {
-                    scancode = 0xE059;
-                    winuser::VK_PAUSE
-                }
-                // VK_SCROLL has an incorrect vkey value when used with modifiers.
-                0x46 => winuser::VK_SCROLL,
-                _ => vkey,
-            }
-        }
-    };
-    Some((vkey, scancode))
+        // VK_SCROLL has an incorrect vkey value when used with modifiers.
+        0x46 => winuser::VK_SCROLL,
+        _ => vkey,
+      }
+    }
+  };
+  Some((vkey, scancode))
 }
 
 pub fn process_key_params(
-    wparam: WPARAM,
-    lparam: LPARAM,
+  wparam: WPARAM,
+  lparam: LPARAM,
 ) -> Option<(ScanCode, Option<VirtualKeyCode>)> {
-    let scancode = ((lparam >> 16) & 0xff) as UINT;
-    let extended = (lparam & 0x01000000) != 0;
-    handle_extended_keys(wparam as _, scancode, extended)
-        .map(|(vkey, scancode)| (scancode, vkey_to_winit_vkey(vkey)))
+  let scancode = ((lparam >> 16) & 0xff) as UINT;
+  let extended = (lparam & 0x01000000) != 0;
+  handle_extended_keys(wparam as _, scancode, extended)
+    .map(|(vkey, scancode)| (scancode, vkey_to_winit_vkey(vkey)))
 }
 
 // This is needed as windows doesn't properly distinguish
 // some virtual key codes for different keyboard layouts
 fn map_text_keys(win_virtual_key: i32) -> Option<VirtualKeyCode> {
-    let char_key =
-        unsafe { winuser::MapVirtualKeyA(win_virtual_key as u32, winuser::MAPVK_VK_TO_CHAR) }
-            & 0x7FFF;
-    match char::from_u32(char_key) {
-        Some(';') => Some(VirtualKeyCode::Semicolon),
-        Some('/') => Some(VirtualKeyCode::Slash),
-        Some('`') => Some(VirtualKeyCode::Grave),
-        Some('[') => Some(VirtualKeyCode::LBracket),
-        Some(']') => Some(VirtualKeyCode::RBracket),
-        Some('\'') => Some(VirtualKeyCode::Apostrophe),
-        Some('\\') => Some(VirtualKeyCode::Backslash),
-        _ => None,
-    }
+  let char_key =
+    unsafe { winuser::MapVirtualKeyA(win_virtual_key as u32, winuser::MAPVK_VK_TO_CHAR) } & 0x7FFF;
+  match char::from_u32(char_key) {
+    Some(';') => Some(VirtualKeyCode::Semicolon),
+    Some('/') => Some(VirtualKeyCode::Slash),
+    Some('`') => Some(VirtualKeyCode::Grave),
+    Some('[') => Some(VirtualKeyCode::LBracket),
+    Some(']') => Some(VirtualKeyCode::RBracket),
+    Some('\'') => Some(VirtualKeyCode::Apostrophe),
+    Some('\\') => Some(VirtualKeyCode::Backslash),
+    _ => None,
+  }
 }

src/platform_impl/windows/event_loop/runner.rs

@@ -1,41 +1,41 @@
 use std::{
-    any::Any,
-    cell::{Cell, RefCell},
-    collections::{HashSet, VecDeque},
-    mem, panic, ptr,
-    rc::Rc,
-    time::Instant,
+  any::Any,
+  cell::{Cell, RefCell},
+  collections::{HashSet, VecDeque},
+  mem, panic, ptr,
+  rc::Rc,
+  time::Instant,
 };
 
 use winapi::{
-    shared::{minwindef::DWORD, windef::HWND},
-    um::winuser,
+  shared::{minwindef::DWORD, windef::HWND},
+  um::winuser,
 };
 
 use crate::{
-    dpi::PhysicalSize,
-    event::{Event, StartCause, WindowEvent},
-    event_loop::ControlFlow,
-    platform_impl::platform::util,
-    window::WindowId,
+  dpi::PhysicalSize,
+  event::{Event, StartCause, WindowEvent},
+  event_loop::ControlFlow,
+  platform_impl::platform::util,
+  window::WindowId,
 };
 
 pub(crate) type EventLoopRunnerShared<T> = Rc<EventLoopRunner<T>>;
 pub(crate) struct EventLoopRunner<T: 'static> {
-    // The event loop's win32 handles
-    thread_msg_target: HWND,
-    wait_thread_id: DWORD,
+  // The event loop's win32 handles
+  thread_msg_target: HWND,
+  wait_thread_id: DWORD,
 
-    control_flow: Cell<ControlFlow>,
-    runner_state: Cell<RunnerState>,
-    last_events_cleared: Cell<Instant>,
+  control_flow: Cell<ControlFlow>,
+  runner_state: Cell<RunnerState>,
+  last_events_cleared: Cell<Instant>,
 
-    event_handler: Cell<Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>>,
-    event_buffer: RefCell<VecDeque<BufferedEvent<T>>>,
+  event_handler: Cell<Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>>,
+  event_buffer: RefCell<VecDeque<BufferedEvent<T>>>,
 
-    owned_windows: Cell<HashSet<HWND>>,
+  owned_windows: Cell<HashSet<HWND>>,
 
-    panic_error: Cell<Option<PanicError>>,
+  panic_error: Cell<Option<PanicError>>,
 }
 
 pub type PanicError = Box<dyn Any + Send + 'static>;
@@ -43,200 +43,201 @@ pub type PanicError = Box<dyn Any + Send + 'static>;
 /// See `move_state_to` function for details on how the state loop works.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum RunnerState {
-    /// The event loop has just been created, and an `Init` event must be sent.
-    Uninitialized,
-    /// The event loop is idling.
-    Idle,
-    /// The event loop is handling the OS's events and sending them to the user's callback.
-    /// `NewEvents` has been sent, and `MainEventsCleared` hasn't.
-    HandlingMainEvents,
-    /// The event loop is handling the redraw events and sending them to the user's callback.
-    /// `MainEventsCleared` has been sent, and `RedrawEventsCleared` hasn't.
-    HandlingRedrawEvents,
-    /// The event loop has been destroyed. No other events will be emitted.
-    Destroyed,
+  /// The event loop has just been created, and an `Init` event must be sent.
+  Uninitialized,
+  /// The event loop is idling.
+  Idle,
+  /// The event loop is handling the OS's events and sending them to the user's callback.
+  /// `NewEvents` has been sent, and `MainEventsCleared` hasn't.
+  HandlingMainEvents,
+  /// The event loop is handling the redraw events and sending them to the user's callback.
+  /// `MainEventsCleared` has been sent, and `RedrawEventsCleared` hasn't.
+  HandlingRedrawEvents,
+  /// The event loop has been destroyed. No other events will be emitted.
+  Destroyed,
 }
 
 enum BufferedEvent<T: 'static> {
-    Event(Event<'static, T>),
-    ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
+  Event(Event<'static, T>),
+  ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
 }
 
 impl<T> EventLoopRunner<T> {
-    pub(crate) fn new(thread_msg_target: HWND, wait_thread_id: DWORD) -> EventLoopRunner<T> {
-        EventLoopRunner {
-            thread_msg_target,
-            wait_thread_id,
-            runner_state: Cell::new(RunnerState::Uninitialized),
-            control_flow: Cell::new(ControlFlow::Poll),
-            panic_error: Cell::new(None),
-            last_events_cleared: Cell::new(Instant::now()),
-            event_handler: Cell::new(None),
-            event_buffer: RefCell::new(VecDeque::new()),
-            owned_windows: Cell::new(HashSet::new()),
-        }
+  pub(crate) fn new(thread_msg_target: HWND, wait_thread_id: DWORD) -> EventLoopRunner<T> {
+    EventLoopRunner {
+      thread_msg_target,
+      wait_thread_id,
+      runner_state: Cell::new(RunnerState::Uninitialized),
+      control_flow: Cell::new(ControlFlow::Poll),
+      panic_error: Cell::new(None),
+      last_events_cleared: Cell::new(Instant::now()),
+      event_handler: Cell::new(None),
+      event_buffer: RefCell::new(VecDeque::new()),
+      owned_windows: Cell::new(HashSet::new()),
     }
+  }
 
-    pub(crate) unsafe fn set_event_handler<F>(&self, f: F)
-    where
-        F: FnMut(Event<'_, T>, &mut ControlFlow),
-    {
-        let old_event_handler = self.event_handler.replace(mem::transmute::<
-            Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>,
-            Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>,
-        >(Some(Box::new(f))));
-        assert!(old_event_handler.is_none());
-    }
+  pub(crate) unsafe fn set_event_handler<F>(&self, f: F)
+  where
+    F: FnMut(Event<'_, T>, &mut ControlFlow),
+  {
+    let old_event_handler = self.event_handler.replace(mem::transmute::<
+      Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>,
+      Option<Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>>,
+    >(Some(Box::new(f))));
+    assert!(old_event_handler.is_none());
+  }
 
-    pub(crate) fn reset_runner(&self) {
-        let EventLoopRunner {
-            thread_msg_target: _,
-            wait_thread_id: _,
-            runner_state,
-            panic_error,
-            control_flow,
-            last_events_cleared: _,
-            event_handler,
-            event_buffer: _,
-            owned_windows: _,
-        } = self;
-        runner_state.set(RunnerState::Uninitialized);
-        panic_error.set(None);
-        control_flow.set(ControlFlow::Poll);
-        event_handler.set(None);
-    }
+  pub(crate) fn reset_runner(&self) {
+    let EventLoopRunner {
+      thread_msg_target: _,
+      wait_thread_id: _,
+      runner_state,
+      panic_error,
+      control_flow,
+      last_events_cleared: _,
+      event_handler,
+      event_buffer: _,
+      owned_windows: _,
+    } = self;
+    runner_state.set(RunnerState::Uninitialized);
+    panic_error.set(None);
+    control_flow.set(ControlFlow::Poll);
+    event_handler.set(None);
+  }
 }
 
 /// State retrieval functions.
 impl<T> EventLoopRunner<T> {
-    pub fn thread_msg_target(&self) -> HWND {
-        self.thread_msg_target
-    }
+  pub fn thread_msg_target(&self) -> HWND {
+    self.thread_msg_target
+  }
 
-    pub fn wait_thread_id(&self) -> DWORD {
-        self.wait_thread_id
-    }
+  pub fn wait_thread_id(&self) -> DWORD {
+    self.wait_thread_id
+  }
 
-    pub fn redrawing(&self) -> bool {
-        self.runner_state.get() == RunnerState::HandlingRedrawEvents
-    }
+  pub fn redrawing(&self) -> bool {
+    self.runner_state.get() == RunnerState::HandlingRedrawEvents
+  }
 
-    pub fn take_panic_error(&self) -> Result<(), PanicError> {
-        match self.panic_error.take() {
-            Some(err) => Err(err),
-            None => Ok(()),
-        }
+  pub fn take_panic_error(&self) -> Result<(), PanicError> {
+    match self.panic_error.take() {
+      Some(err) => Err(err),
+      None => Ok(()),
     }
+  }
 
-    pub fn control_flow(&self) -> ControlFlow {
-        self.control_flow.get()
-    }
+  pub fn control_flow(&self) -> ControlFlow {
+    self.control_flow.get()
+  }
 
-    pub fn handling_events(&self) -> bool {
-        self.runner_state.get() != RunnerState::Idle
-    }
+  pub fn handling_events(&self) -> bool {
+    self.runner_state.get() != RunnerState::Idle
+  }
 
-    pub fn should_buffer(&self) -> bool {
-        let handler = self.event_handler.take();
-        let should_buffer = handler.is_none();
-        self.event_handler.set(handler);
-        should_buffer
-    }
+  pub fn should_buffer(&self) -> bool {
+    let handler = self.event_handler.take();
+    let should_buffer = handler.is_none();
+    self.event_handler.set(handler);
+    should_buffer
+  }
 }
 
 /// Misc. functions
 impl<T> EventLoopRunner<T> {
-    pub fn catch_unwind<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
-        let panic_error = self.panic_error.take();
-        if panic_error.is_none() {
-            let result = panic::catch_unwind(panic::AssertUnwindSafe(f));
+  pub fn catch_unwind<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
+    let panic_error = self.panic_error.take();
+    if panic_error.is_none() {
+      let result = panic::catch_unwind(panic::AssertUnwindSafe(f));
 
-            // Check to see if the panic error was set in a re-entrant call to catch_unwind inside
-            // of `f`. If it was, that error takes priority. If it wasn't, check if our call to
-            // catch_unwind caught any panics and set panic_error appropriately.
-            match self.panic_error.take() {
-                None => match result {
-                    Ok(r) => Some(r),
-                    Err(e) => {
-                        self.panic_error.set(Some(e));
-                        None
-                    }
-                },
-                Some(e) => {
-                    self.panic_error.set(Some(e));
-                    None
-                }
-            }
-        } else {
-            self.panic_error.set(panic_error);
+      // Check to see if the panic error was set in a re-entrant call to catch_unwind inside
+      // of `f`. If it was, that error takes priority. If it wasn't, check if our call to
+      // catch_unwind caught any panics and set panic_error appropriately.
+      match self.panic_error.take() {
+        None => match result {
+          Ok(r) => Some(r),
+          Err(e) => {
+            self.panic_error.set(Some(e));
             None
+          }
+        },
+        Some(e) => {
+          self.panic_error.set(Some(e));
+          None
         }
+      }
+    } else {
+      self.panic_error.set(panic_error);
+      None
     }
-    pub fn register_window(&self, window: HWND) {
-        let mut owned_windows = self.owned_windows.take();
-        owned_windows.insert(window);
-        self.owned_windows.set(owned_windows);
-    }
+  }
+  pub fn register_window(&self, window: HWND) {
+    let mut owned_windows = self.owned_windows.take();
+    owned_windows.insert(window);
+    self.owned_windows.set(owned_windows);
+  }
 
-    pub fn remove_window(&self, window: HWND) {
-        let mut owned_windows = self.owned_windows.take();
-        owned_windows.remove(&window);
-        self.owned_windows.set(owned_windows);
-    }
+  pub fn remove_window(&self, window: HWND) {
+    let mut owned_windows = self.owned_windows.take();
+    owned_windows.remove(&window);
+    self.owned_windows.set(owned_windows);
+  }
 
-    pub fn owned_windows(&self, mut f: impl FnMut(HWND)) {
-        let mut owned_windows = self.owned_windows.take();
-        for hwnd in &owned_windows {
-            f(*hwnd);
-        }
-        let new_owned_windows = self.owned_windows.take();
-        owned_windows.extend(&new_owned_windows);
-        self.owned_windows.set(owned_windows);
+  pub fn owned_windows(&self, mut f: impl FnMut(HWND)) {
+    let mut owned_windows = self.owned_windows.take();
+    for hwnd in &owned_windows {
+      f(*hwnd);
     }
+    let new_owned_windows = self.owned_windows.take();
+    owned_windows.extend(&new_owned_windows);
+    self.owned_windows.set(owned_windows);
+  }
 }
 
 /// Event dispatch functions.
 impl<T> EventLoopRunner<T> {
-    pub(crate) unsafe fn poll(&self) {
-        self.move_state_to(RunnerState::HandlingMainEvents);
-    }
+  pub(crate) unsafe fn poll(&self) {
+    self.move_state_to(RunnerState::HandlingMainEvents);
+  }
 
-    pub(crate) unsafe fn send_event(&self, event: Event<'_, T>) {
-        if let Event::RedrawRequested(_) = event {
-            if self.runner_state.get() != RunnerState::HandlingRedrawEvents {
-                warn!("RedrawRequested dispatched without explicit MainEventsCleared");
-                self.move_state_to(RunnerState::HandlingRedrawEvents);
-            }
-            self.call_event_handler(event);
-        } else {
-            if self.should_buffer() {
-                // If the runner is already borrowed, we're in the middle of an event loop invocation. Add
-                // the event to a buffer to be processed later.
-                self.event_buffer
-                    .borrow_mut()
-                    .push_back(BufferedEvent::from_event(event))
-            } else {
-                self.move_state_to(RunnerState::HandlingMainEvents);
-                self.call_event_handler(event);
-                self.dispatch_buffered_events();
-            }
-        }
-    }
-
-    pub(crate) unsafe fn main_events_cleared(&self) {
+  pub(crate) unsafe fn send_event(&self, event: Event<'_, T>) {
+    if let Event::RedrawRequested(_) = event {
+      if self.runner_state.get() != RunnerState::HandlingRedrawEvents {
+        warn!("RedrawRequested dispatched without explicit MainEventsCleared");
         self.move_state_to(RunnerState::HandlingRedrawEvents);
+      }
+      self.call_event_handler(event);
+    } else {
+      if self.should_buffer() {
+        // If the runner is already borrowed, we're in the middle of an event loop invocation. Add
+        // the event to a buffer to be processed later.
+        self
+          .event_buffer
+          .borrow_mut()
+          .push_back(BufferedEvent::from_event(event))
+      } else {
+        self.move_state_to(RunnerState::HandlingMainEvents);
+        self.call_event_handler(event);
+        self.dispatch_buffered_events();
+      }
     }
+  }
 
-    pub(crate) unsafe fn redraw_events_cleared(&self) {
-        self.move_state_to(RunnerState::Idle);
-    }
+  pub(crate) unsafe fn main_events_cleared(&self) {
+    self.move_state_to(RunnerState::HandlingRedrawEvents);
+  }
 
-    pub(crate) unsafe fn loop_destroyed(&self) {
-        self.move_state_to(RunnerState::Destroyed);
-    }
+  pub(crate) unsafe fn redraw_events_cleared(&self) {
+    self.move_state_to(RunnerState::Idle);
+  }
 
-    unsafe fn call_event_handler(&self, event: Event<'_, T>) {
-        self.catch_unwind(|| {
+  pub(crate) unsafe fn loop_destroyed(&self) {
+    self.move_state_to(RunnerState::Destroyed);
+  }
+
+  unsafe fn call_event_handler(&self, event: Event<'_, T>) {
+    self.catch_unwind(|| {
             let mut control_flow = self.control_flow.take();
             let mut event_handler = self.event_handler.take()
                 .expect("either event handler is re-entrant (likely), or no event handler is registered (very unlikely)");
@@ -250,194 +251,192 @@ impl<T> EventLoopRunner<T> {
             assert!(self.event_handler.replace(Some(event_handler)).is_none());
             self.control_flow.set(control_flow);
         });
-    }
+  }
 
-    unsafe fn dispatch_buffered_events(&self) {
-        loop {
-            // We do this instead of using a `while let` loop because if we use a `while let`
-            // loop the reference returned `borrow_mut()` doesn't get dropped until the end
-            // of the loop's body and attempts to add events to the event buffer while in
-            // `process_event` will fail.
-            let buffered_event_opt = self.event_buffer.borrow_mut().pop_front();
-            match buffered_event_opt {
-                Some(e) => e.dispatch_event(|e| self.call_event_handler(e)),
-                None => break,
-            }
+  unsafe fn dispatch_buffered_events(&self) {
+    loop {
+      // We do this instead of using a `while let` loop because if we use a `while let`
+      // loop the reference returned `borrow_mut()` doesn't get dropped until the end
+      // of the loop's body and attempts to add events to the event buffer while in
+      // `process_event` will fail.
+      let buffered_event_opt = self.event_buffer.borrow_mut().pop_front();
+      match buffered_event_opt {
+        Some(e) => e.dispatch_event(|e| self.call_event_handler(e)),
+        None => break,
+      }
+    }
+  }
+
+  /// Dispatch control flow events (`NewEvents`, `MainEventsCleared`, `RedrawEventsCleared`, and
+  /// `LoopDestroyed`) as necessary to bring the internal `RunnerState` to the new runner state.
+  ///
+  /// The state transitions are defined as follows:
+  ///
+  /// ```text
+  ///    Uninitialized
+  ///          |
+  ///          V
+  ///  HandlingMainEvents
+  ///   ^            |
+  ///   |            V
+  /// Idle <--- HandlingRedrawEvents
+  ///   |
+  ///   V
+  /// Destroyed
+  /// ```
+  ///
+  /// Attempting to transition back to `Uninitialized` will result in a panic. Attempting to
+  /// transition *from* `Destroyed` will also reuslt in a panic. Transitioning to the current
+  /// state is a no-op. Even if the `new_runner_state` isn't the immediate next state in the
+  /// runner state machine (e.g. `self.runner_state == HandlingMainEvents` and
+  /// `new_runner_state == Idle`), the intermediate state transitions will still be executed.
+  unsafe fn move_state_to(&self, new_runner_state: RunnerState) {
+    use RunnerState::{Destroyed, HandlingMainEvents, HandlingRedrawEvents, Idle, Uninitialized};
+
+    match (
+      self.runner_state.replace(new_runner_state),
+      new_runner_state,
+    ) {
+      (Uninitialized, Uninitialized)
+      | (Idle, Idle)
+      | (HandlingMainEvents, HandlingMainEvents)
+      | (HandlingRedrawEvents, HandlingRedrawEvents)
+      | (Destroyed, Destroyed) => (),
+
+      // State transitions that initialize the event loop.
+      (Uninitialized, HandlingMainEvents) => {
+        self.call_new_events(true);
+      }
+      (Uninitialized, HandlingRedrawEvents) => {
+        self.call_new_events(true);
+        self.call_event_handler(Event::MainEventsCleared);
+      }
+      (Uninitialized, Idle) => {
+        self.call_new_events(true);
+        self.call_event_handler(Event::MainEventsCleared);
+        self.call_redraw_events_cleared();
+      }
+      (Uninitialized, Destroyed) => {
+        self.call_new_events(true);
+        self.call_event_handler(Event::MainEventsCleared);
+        self.call_redraw_events_cleared();
+        self.call_event_handler(Event::LoopDestroyed);
+      }
+      (_, Uninitialized) => panic!("cannot move state to Uninitialized"),
+
+      // State transitions that start the event handling process.
+      (Idle, HandlingMainEvents) => {
+        self.call_new_events(false);
+      }
+      (Idle, HandlingRedrawEvents) => {
+        self.call_new_events(false);
+        self.call_event_handler(Event::MainEventsCleared);
+      }
+      (Idle, Destroyed) => {
+        self.call_event_handler(Event::LoopDestroyed);
+      }
+
+      (HandlingMainEvents, HandlingRedrawEvents) => {
+        self.call_event_handler(Event::MainEventsCleared);
+      }
+      (HandlingMainEvents, Idle) => {
+        warn!("RedrawEventsCleared emitted without explicit MainEventsCleared");
+        self.call_event_handler(Event::MainEventsCleared);
+        self.call_redraw_events_cleared();
+      }
+      (HandlingMainEvents, Destroyed) => {
+        self.call_event_handler(Event::MainEventsCleared);
+        self.call_redraw_events_cleared();
+        self.call_event_handler(Event::LoopDestroyed);
+      }
+
+      (HandlingRedrawEvents, Idle) => {
+        self.call_redraw_events_cleared();
+      }
+      (HandlingRedrawEvents, HandlingMainEvents) => {
+        warn!("NewEvents emitted without explicit RedrawEventsCleared");
+        self.call_redraw_events_cleared();
+        self.call_new_events(false);
+      }
+      (HandlingRedrawEvents, Destroyed) => {
+        self.call_redraw_events_cleared();
+        self.call_event_handler(Event::LoopDestroyed);
+      }
+
+      (Destroyed, _) => panic!("cannot move state from Destroyed"),
+    }
+  }
+
+  unsafe fn call_new_events(&self, init: bool) {
+    let start_cause = match (init, self.control_flow()) {
+      (true, _) => StartCause::Init,
+      (false, ControlFlow::Poll) => StartCause::Poll,
+      (false, ControlFlow::Exit) | (false, ControlFlow::Wait) => StartCause::WaitCancelled {
+        requested_resume: None,
+        start: self.last_events_cleared.get(),
+      },
+      (false, ControlFlow::WaitUntil(requested_resume)) => {
+        if Instant::now() < requested_resume {
+          StartCause::WaitCancelled {
+            requested_resume: Some(requested_resume),
+            start: self.last_events_cleared.get(),
+          }
+        } else {
+          StartCause::ResumeTimeReached {
+            requested_resume,
+            start: self.last_events_cleared.get(),
+          }
         }
-    }
+      }
+    };
+    self.call_event_handler(Event::NewEvents(start_cause));
+    self.dispatch_buffered_events();
+    winuser::RedrawWindow(
+      self.thread_msg_target,
+      ptr::null(),
+      ptr::null_mut(),
+      winuser::RDW_INTERNALPAINT,
+    );
+  }
 
-    /// Dispatch control flow events (`NewEvents`, `MainEventsCleared`, `RedrawEventsCleared`, and
-    /// `LoopDestroyed`) as necessary to bring the internal `RunnerState` to the new runner state.
-    ///
-    /// The state transitions are defined as follows:
-    ///
-    /// ```text
-    ///    Uninitialized
-    ///          |
-    ///          V
-    ///  HandlingMainEvents
-    ///   ^            |
-    ///   |            V
-    /// Idle <--- HandlingRedrawEvents
-    ///   |
-    ///   V
-    /// Destroyed
-    /// ```
-    ///
-    /// Attempting to transition back to `Uninitialized` will result in a panic. Attempting to
-    /// transition *from* `Destroyed` will also reuslt in a panic. Transitioning to the current
-    /// state is a no-op. Even if the `new_runner_state` isn't the immediate next state in the
-    /// runner state machine (e.g. `self.runner_state == HandlingMainEvents` and
-    /// `new_runner_state == Idle`), the intermediate state transitions will still be executed.
-    unsafe fn move_state_to(&self, new_runner_state: RunnerState) {
-        use RunnerState::{
-            Destroyed, HandlingMainEvents, HandlingRedrawEvents, Idle, Uninitialized,
-        };
-
-        match (
-            self.runner_state.replace(new_runner_state),
-            new_runner_state,
-        ) {
-            (Uninitialized, Uninitialized)
-            | (Idle, Idle)
-            | (HandlingMainEvents, HandlingMainEvents)
-            | (HandlingRedrawEvents, HandlingRedrawEvents)
-            | (Destroyed, Destroyed) => (),
-
-            // State transitions that initialize the event loop.
-            (Uninitialized, HandlingMainEvents) => {
-                self.call_new_events(true);
-            }
-            (Uninitialized, HandlingRedrawEvents) => {
-                self.call_new_events(true);
-                self.call_event_handler(Event::MainEventsCleared);
-            }
-            (Uninitialized, Idle) => {
-                self.call_new_events(true);
-                self.call_event_handler(Event::MainEventsCleared);
-                self.call_redraw_events_cleared();
-            }
-            (Uninitialized, Destroyed) => {
-                self.call_new_events(true);
-                self.call_event_handler(Event::MainEventsCleared);
-                self.call_redraw_events_cleared();
-                self.call_event_handler(Event::LoopDestroyed);
-            }
-            (_, Uninitialized) => panic!("cannot move state to Uninitialized"),
-
-            // State transitions that start the event handling process.
-            (Idle, HandlingMainEvents) => {
-                self.call_new_events(false);
-            }
-            (Idle, HandlingRedrawEvents) => {
-                self.call_new_events(false);
-                self.call_event_handler(Event::MainEventsCleared);
-            }
-            (Idle, Destroyed) => {
-                self.call_event_handler(Event::LoopDestroyed);
-            }
-
-            (HandlingMainEvents, HandlingRedrawEvents) => {
-                self.call_event_handler(Event::MainEventsCleared);
-            }
-            (HandlingMainEvents, Idle) => {
-                warn!("RedrawEventsCleared emitted without explicit MainEventsCleared");
-                self.call_event_handler(Event::MainEventsCleared);
-                self.call_redraw_events_cleared();
-            }
-            (HandlingMainEvents, Destroyed) => {
-                self.call_event_handler(Event::MainEventsCleared);
-                self.call_redraw_events_cleared();
-                self.call_event_handler(Event::LoopDestroyed);
-            }
-
-            (HandlingRedrawEvents, Idle) => {
-                self.call_redraw_events_cleared();
-            }
-            (HandlingRedrawEvents, HandlingMainEvents) => {
-                warn!("NewEvents emitted without explicit RedrawEventsCleared");
-                self.call_redraw_events_cleared();
-                self.call_new_events(false);
-            }
-            (HandlingRedrawEvents, Destroyed) => {
-                self.call_redraw_events_cleared();
-                self.call_event_handler(Event::LoopDestroyed);
-            }
-
-            (Destroyed, _) => panic!("cannot move state from Destroyed"),
-        }
-    }
-
-    unsafe fn call_new_events(&self, init: bool) {
-        let start_cause = match (init, self.control_flow()) {
-            (true, _) => StartCause::Init,
-            (false, ControlFlow::Poll) => StartCause::Poll,
-            (false, ControlFlow::Exit) | (false, ControlFlow::Wait) => StartCause::WaitCancelled {
-                requested_resume: None,
-                start: self.last_events_cleared.get(),
-            },
-            (false, ControlFlow::WaitUntil(requested_resume)) => {
-                if Instant::now() < requested_resume {
-                    StartCause::WaitCancelled {
-                        requested_resume: Some(requested_resume),
-                        start: self.last_events_cleared.get(),
-                    }
-                } else {
-                    StartCause::ResumeTimeReached {
-                        requested_resume,
-                        start: self.last_events_cleared.get(),
-                    }
-                }
-            }
-        };
-        self.call_event_handler(Event::NewEvents(start_cause));
-        self.dispatch_buffered_events();
-        winuser::RedrawWindow(
-            self.thread_msg_target,
-            ptr::null(),
-            ptr::null_mut(),
-            winuser::RDW_INTERNALPAINT,
-        );
-    }
-
-    unsafe fn call_redraw_events_cleared(&self) {
-        self.call_event_handler(Event::RedrawEventsCleared);
-        self.last_events_cleared.set(Instant::now());
-    }
+  unsafe fn call_redraw_events_cleared(&self) {
+    self.call_event_handler(Event::RedrawEventsCleared);
+    self.last_events_cleared.set(Instant::now());
+  }
 }
 
 impl<T> BufferedEvent<T> {
-    pub fn from_event(event: Event<'_, T>) -> BufferedEvent<T> {
-        match event {
-            Event::WindowEvent {
-                event:
-                    WindowEvent::ScaleFactorChanged {
-                        scale_factor,
-                        new_inner_size,
-                    },
-                window_id,
-            } => BufferedEvent::ScaleFactorChanged(window_id, scale_factor, *new_inner_size),
-            event => BufferedEvent::Event(event.to_static().unwrap()),
-        }
+  pub fn from_event(event: Event<'_, T>) -> BufferedEvent<T> {
+    match event {
+      Event::WindowEvent {
+        event:
+          WindowEvent::ScaleFactorChanged {
+            scale_factor,
+            new_inner_size,
+          },
+        window_id,
+      } => BufferedEvent::ScaleFactorChanged(window_id, scale_factor, *new_inner_size),
+      event => BufferedEvent::Event(event.to_static().unwrap()),
     }
+  }
 
-    pub fn dispatch_event(self, dispatch: impl FnOnce(Event<'_, T>)) {
-        match self {
-            Self::Event(event) => dispatch(event),
-            Self::ScaleFactorChanged(window_id, scale_factor, mut new_inner_size) => {
-                dispatch(Event::WindowEvent {
-                    window_id,
-                    event: WindowEvent::ScaleFactorChanged {
-                        scale_factor,
-                        new_inner_size: &mut new_inner_size,
-                    },
-                });
-                util::set_inner_size_physical(
-                    (window_id.0).0,
-                    new_inner_size.width as _,
-                    new_inner_size.height as _,
-                );
-            }
-        }
+  pub fn dispatch_event(self, dispatch: impl FnOnce(Event<'_, T>)) {
+    match self {
+      Self::Event(event) => dispatch(event),
+      Self::ScaleFactorChanged(window_id, scale_factor, mut new_inner_size) => {
+        dispatch(Event::WindowEvent {
+          window_id,
+          event: WindowEvent::ScaleFactorChanged {
+            scale_factor,
+            new_inner_size: &mut new_inner_size,
+          },
+        });
+        util::set_inner_size_physical(
+          (window_id.0).0,
+          new_inner_size.width as _,
+          new_inner_size.height as _,
+        );
+      }
     }
+  }
 }

src/platform_impl/windows/icon.rs

@@ -1,169 +1,169 @@
 use std::{fmt, io, iter::once, mem, os::windows::ffi::OsStrExt, path::Path, ptr, sync::Arc};
 
 use winapi::{
-    ctypes::{c_int, wchar_t},
-    shared::{
-        minwindef::{BYTE, LPARAM, WORD, WPARAM},
-        windef::{HICON, HWND},
-    },
-    um::libloaderapi,
-    um::winuser,
+  ctypes::{c_int, wchar_t},
+  shared::{
+    minwindef::{BYTE, LPARAM, WORD, WPARAM},
+    windef::{HICON, HWND},
+  },
+  um::libloaderapi,
+  um::winuser,
 };
 
 use crate::dpi::PhysicalSize;
 use crate::icon::*;
 
 impl Pixel {
-    fn to_bgra(&mut self) {
-        mem::swap(&mut self.r, &mut self.b);
-    }
+  fn to_bgra(&mut self) {
+    mem::swap(&mut self.r, &mut self.b);
+  }
 }
 
 impl RgbaIcon {
-    fn into_windows_icon(self) -> Result<WinIcon, BadIcon> {
-        let mut rgba = self.rgba;
-        let pixel_count = rgba.len() / PIXEL_SIZE;
-        let mut and_mask = Vec::with_capacity(pixel_count);
-        let pixels =
-            unsafe { std::slice::from_raw_parts_mut(rgba.as_mut_ptr() as *mut Pixel, pixel_count) };
-        for pixel in pixels {
-            and_mask.push(pixel.a.wrapping_sub(std::u8::MAX)); // invert alpha channel
-            pixel.to_bgra();
-        }
-        assert_eq!(and_mask.len(), pixel_count);
-        let handle = unsafe {
-            winuser::CreateIcon(
-                ptr::null_mut(),
-                self.width as c_int,
-                self.height as c_int,
-                1,
-                (PIXEL_SIZE * 8) as BYTE,
-                and_mask.as_ptr() as *const BYTE,
-                rgba.as_ptr() as *const BYTE,
-            ) as HICON
-        };
-        if !handle.is_null() {
-            Ok(WinIcon::from_handle(handle))
-        } else {
-            Err(BadIcon::OsError(io::Error::last_os_error()))
-        }
+  fn into_windows_icon(self) -> Result<WinIcon, BadIcon> {
+    let mut rgba = self.rgba;
+    let pixel_count = rgba.len() / PIXEL_SIZE;
+    let mut and_mask = Vec::with_capacity(pixel_count);
+    let pixels =
+      unsafe { std::slice::from_raw_parts_mut(rgba.as_mut_ptr() as *mut Pixel, pixel_count) };
+    for pixel in pixels {
+      and_mask.push(pixel.a.wrapping_sub(std::u8::MAX)); // invert alpha channel
+      pixel.to_bgra();
     }
+    assert_eq!(and_mask.len(), pixel_count);
+    let handle = unsafe {
+      winuser::CreateIcon(
+        ptr::null_mut(),
+        self.width as c_int,
+        self.height as c_int,
+        1,
+        (PIXEL_SIZE * 8) as BYTE,
+        and_mask.as_ptr() as *const BYTE,
+        rgba.as_ptr() as *const BYTE,
+      ) as HICON
+    };
+    if !handle.is_null() {
+      Ok(WinIcon::from_handle(handle))
+    } else {
+      Err(BadIcon::OsError(io::Error::last_os_error()))
+    }
+  }
 }
 
 #[derive(Debug)]
 pub enum IconType {
-    Small = winuser::ICON_SMALL as isize,
-    Big = winuser::ICON_BIG as isize,
+  Small = winuser::ICON_SMALL as isize,
+  Big = winuser::ICON_BIG as isize,
 }
 
 #[derive(Debug)]
 struct RaiiIcon {
-    handle: HICON,
+  handle: HICON,
 }
 
 #[derive(Clone)]
 pub struct WinIcon {
-    inner: Arc<RaiiIcon>,
+  inner: Arc<RaiiIcon>,
 }
 
 unsafe impl Send for WinIcon {}
 
 impl WinIcon {
-    pub fn as_raw_handle(&self) -> HICON {
-        self.inner.handle
+  pub fn as_raw_handle(&self) -> HICON {
+    self.inner.handle
+  }
+
+  pub fn from_path<P: AsRef<Path>>(
+    path: P,
+    size: Option<PhysicalSize<u32>>,
+  ) -> Result<Self, BadIcon> {
+    let wide_path: Vec<u16> = path
+      .as_ref()
+      .as_os_str()
+      .encode_wide()
+      .chain(once(0))
+      .collect();
+
+    // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
+    let (width, height) = size.map(Into::into).unwrap_or((0, 0));
+
+    let handle = unsafe {
+      winuser::LoadImageW(
+        ptr::null_mut(),
+        wide_path.as_ptr() as *const wchar_t,
+        winuser::IMAGE_ICON,
+        width as c_int,
+        height as c_int,
+        winuser::LR_DEFAULTSIZE | winuser::LR_LOADFROMFILE,
+      ) as HICON
+    };
+    if !handle.is_null() {
+      Ok(WinIcon::from_handle(handle))
+    } else {
+      Err(BadIcon::OsError(io::Error::last_os_error()))
     }
+  }
 
-    pub fn from_path<P: AsRef<Path>>(
-        path: P,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        let wide_path: Vec<u16> = path
-            .as_ref()
-            .as_os_str()
-            .encode_wide()
-            .chain(once(0))
-            .collect();
-
-        // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
-        let (width, height) = size.map(Into::into).unwrap_or((0, 0));
-
-        let handle = unsafe {
-            winuser::LoadImageW(
-                ptr::null_mut(),
-                wide_path.as_ptr() as *const wchar_t,
-                winuser::IMAGE_ICON,
-                width as c_int,
-                height as c_int,
-                winuser::LR_DEFAULTSIZE | winuser::LR_LOADFROMFILE,
-            ) as HICON
-        };
-        if !handle.is_null() {
-            Ok(WinIcon::from_handle(handle))
-        } else {
-            Err(BadIcon::OsError(io::Error::last_os_error()))
-        }
+  pub fn from_resource(
+    resource_id: WORD,
+    size: Option<PhysicalSize<u32>>,
+  ) -> Result<Self, BadIcon> {
+    // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
+    let (width, height) = size.map(Into::into).unwrap_or((0, 0));
+    let handle = unsafe {
+      winuser::LoadImageW(
+        libloaderapi::GetModuleHandleW(ptr::null_mut()),
+        winuser::MAKEINTRESOURCEW(resource_id),
+        winuser::IMAGE_ICON,
+        width as c_int,
+        height as c_int,
+        winuser::LR_DEFAULTSIZE,
+      ) as HICON
+    };
+    if !handle.is_null() {
+      Ok(WinIcon::from_handle(handle))
+    } else {
+      Err(BadIcon::OsError(io::Error::last_os_error()))
     }
+  }
 
-    pub fn from_resource(
-        resource_id: WORD,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
-        let (width, height) = size.map(Into::into).unwrap_or((0, 0));
-        let handle = unsafe {
-            winuser::LoadImageW(
-                libloaderapi::GetModuleHandleW(ptr::null_mut()),
-                winuser::MAKEINTRESOURCEW(resource_id),
-                winuser::IMAGE_ICON,
-                width as c_int,
-                height as c_int,
-                winuser::LR_DEFAULTSIZE,
-            ) as HICON
-        };
-        if !handle.is_null() {
-            Ok(WinIcon::from_handle(handle))
-        } else {
-            Err(BadIcon::OsError(io::Error::last_os_error()))
-        }
-    }
+  pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+    let rgba_icon = RgbaIcon::from_rgba(rgba, width, height)?;
+    rgba_icon.into_windows_icon()
+  }
 
-    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-        let rgba_icon = RgbaIcon::from_rgba(rgba, width, height)?;
-        rgba_icon.into_windows_icon()
+  pub fn set_for_window(&self, hwnd: HWND, icon_type: IconType) {
+    unsafe {
+      winuser::SendMessageW(
+        hwnd,
+        winuser::WM_SETICON,
+        icon_type as WPARAM,
+        self.as_raw_handle() as LPARAM,
+      );
     }
+  }
 
-    pub fn set_for_window(&self, hwnd: HWND, icon_type: IconType) {
-        unsafe {
-            winuser::SendMessageW(
-                hwnd,
-                winuser::WM_SETICON,
-                icon_type as WPARAM,
-                self.as_raw_handle() as LPARAM,
-            );
-        }
-    }
-
-    fn from_handle(handle: HICON) -> Self {
-        Self {
-            inner: Arc::new(RaiiIcon { handle }),
-        }
+  fn from_handle(handle: HICON) -> Self {
+    Self {
+      inner: Arc::new(RaiiIcon { handle }),
     }
+  }
 }
 
 impl Drop for RaiiIcon {
-    fn drop(&mut self) {
-        unsafe { winuser::DestroyIcon(self.handle) };
-    }
+  fn drop(&mut self) {
+    unsafe { winuser::DestroyIcon(self.handle) };
+  }
 }
 
 impl fmt::Debug for WinIcon {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        (*self.inner).fmt(formatter)
-    }
+  fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    (*self.inner).fmt(formatter)
+  }
 }
 
 pub fn unset_for_window(hwnd: HWND, icon_type: IconType) {
-    unsafe {
-        winuser::SendMessageW(hwnd, winuser::WM_SETICON, icon_type as WPARAM, 0 as LPARAM);
-    }
+  unsafe {
+    winuser::SendMessageW(hwnd, winuser::WM_SETICON, icon_type as WPARAM, 0 as LPARAM);
+  }
 }

src/platform_impl/windows/mod.rs

@@ -3,10 +3,10 @@
 use winapi::{self, shared::windef::HMENU, shared::windef::HWND};
 
 pub use self::{
-    event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
-    icon::WinIcon,
-    monitor::{MonitorHandle, VideoMode},
-    window::Window,
+  event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
+  icon::WinIcon,
+  monitor::{MonitorHandle, VideoMode},
+  window::Window,
 };
 
 pub use self::icon::WinIcon as PlatformIcon;
@@ -17,32 +17,32 @@ use crate::window::Theme;
 
 #[derive(Clone)]
 pub enum Parent {
-    None,
-    ChildOf(HWND),
-    OwnedBy(HWND),
+  None,
+  ChildOf(HWND),
+  OwnedBy(HWND),
 }
 
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
-    pub parent: Parent,
-    pub menu: Option<HMENU>,
-    pub taskbar_icon: Option<Icon>,
-    pub no_redirection_bitmap: bool,
-    pub drag_and_drop: bool,
-    pub preferred_theme: Option<Theme>,
+  pub parent: Parent,
+  pub menu: Option<HMENU>,
+  pub taskbar_icon: Option<Icon>,
+  pub no_redirection_bitmap: bool,
+  pub drag_and_drop: bool,
+  pub preferred_theme: Option<Theme>,
 }
 
 impl Default for PlatformSpecificWindowBuilderAttributes {
-    fn default() -> Self {
-        Self {
-            parent: Parent::None,
-            menu: None,
-            taskbar_icon: None,
-            no_redirection_bitmap: false,
-            drag_and_drop: true,
-            preferred_theme: None,
-        }
+  fn default() -> Self {
+    Self {
+      parent: Parent::None,
+      menu: None,
+      taskbar_icon: None,
+      no_redirection_bitmap: false,
+      drag_and_drop: true,
+      preferred_theme: None,
     }
+  }
 }
 
 unsafe impl Send for PlatformSpecificWindowBuilderAttributes {}
@@ -58,26 +58,26 @@ unsafe impl Sync for Cursor {}
 pub struct DeviceId(u32);
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
-        DeviceId(0)
-    }
+  pub unsafe fn dummy() -> Self {
+    DeviceId(0)
+  }
 }
 
 impl DeviceId {
-    pub fn persistent_identifier(&self) -> Option<String> {
-        if self.0 != 0 {
-            raw_input::get_raw_input_device_name(self.0 as _)
-        } else {
-            None
-        }
+  pub fn persistent_identifier(&self) -> Option<String> {
+    if self.0 != 0 {
+      raw_input::get_raw_input_device_name(self.0 as _)
+    } else {
+      None
     }
+  }
 }
 
 // Constant device ID, to be removed when this backend is updated to report real device IDs.
 const DEVICE_ID: RootDeviceId = RootDeviceId(DeviceId(0));
 
 fn wrap_device_id(id: u32) -> RootDeviceId {
-    RootDeviceId(DeviceId(id))
+  RootDeviceId(DeviceId(id))
 }
 
 pub type OsError = std::io::Error;
@@ -88,11 +88,11 @@ unsafe impl Send for WindowId {}
 unsafe impl Sync for WindowId {}
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
-        use std::ptr::null_mut;
+  pub unsafe fn dummy() -> Self {
+    use std::ptr::null_mut;
 
-        WindowId(null_mut())
-    }
+    WindowId(null_mut())
+  }
 }
 
 #[macro_use]

src/platform_impl/windows/monitor.rs

@@ -1,84 +1,84 @@
 use winapi::{
-    shared::{
-        minwindef::{BOOL, DWORD, LPARAM, TRUE, WORD},
-        windef::{HDC, HMONITOR, HWND, LPRECT, POINT},
-    },
-    um::{wingdi, winuser},
+  shared::{
+    minwindef::{BOOL, DWORD, LPARAM, TRUE, WORD},
+    windef::{HDC, HMONITOR, HWND, LPRECT, POINT},
+  },
+  um::{wingdi, winuser},
 };
 
 use std::{
-    collections::{BTreeSet, VecDeque},
-    io, mem, ptr,
+  collections::{BTreeSet, VecDeque},
+  io, mem, ptr,
 };
 
 use super::util;
 use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
-    platform_impl::platform::{
-        dpi::{dpi_to_scale_factor, get_monitor_dpi},
-        window::Window,
-    },
+  dpi::{PhysicalPosition, PhysicalSize},
+  monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+  platform_impl::platform::{
+    dpi::{dpi_to_scale_factor, get_monitor_dpi},
+    window::Window,
+  },
 };
 
 #[derive(Clone)]
 pub struct VideoMode {
-    pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate: u16,
-    pub(crate) monitor: MonitorHandle,
-    pub(crate) native_video_mode: wingdi::DEVMODEW,
+  pub(crate) size: (u32, u32),
+  pub(crate) bit_depth: u16,
+  pub(crate) refresh_rate: u16,
+  pub(crate) monitor: MonitorHandle,
+  pub(crate) native_video_mode: wingdi::DEVMODEW,
 }
 
 impl PartialEq for VideoMode {
-    fn eq(&self, other: &Self) -> bool {
-        self.size == other.size
-            && self.bit_depth == other.bit_depth
-            && self.refresh_rate == other.refresh_rate
-            && self.monitor == other.monitor
-    }
+  fn eq(&self, other: &Self) -> bool {
+    self.size == other.size
+      && self.bit_depth == other.bit_depth
+      && self.refresh_rate == other.refresh_rate
+      && self.monitor == other.monitor
+  }
 }
 
 impl Eq for VideoMode {}
 
 impl std::hash::Hash for VideoMode {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.size.hash(state);
-        self.bit_depth.hash(state);
-        self.refresh_rate.hash(state);
-        self.monitor.hash(state);
-    }
+  fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    self.size.hash(state);
+    self.bit_depth.hash(state);
+    self.refresh_rate.hash(state);
+    self.monitor.hash(state);
+  }
 }
 
 impl std::fmt::Debug for VideoMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("VideoMode")
-            .field("size", &self.size)
-            .field("bit_depth", &self.bit_depth)
-            .field("refresh_rate", &self.refresh_rate)
-            .field("monitor", &self.monitor)
-            .finish()
-    }
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("VideoMode")
+      .field("size", &self.size)
+      .field("bit_depth", &self.bit_depth)
+      .field("refresh_rate", &self.refresh_rate)
+      .field("monitor", &self.monitor)
+      .finish()
+  }
 }
 
 impl VideoMode {
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.size.into()
-    }
+  pub fn size(&self) -> PhysicalSize<u32> {
+    self.size.into()
+  }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
-    }
+  pub fn bit_depth(&self) -> u16 {
+    self.bit_depth
+  }
 
-    pub fn refresh_rate(&self) -> u16 {
-        self.refresh_rate
-    }
+  pub fn refresh_rate(&self) -> u16 {
+    self.refresh_rate
+  }
 
-    pub fn monitor(&self) -> RootMonitorHandle {
-        RootMonitorHandle {
-            inner: self.monitor.clone(),
-        }
+  pub fn monitor(&self) -> RootMonitorHandle {
+    RootMonitorHandle {
+      inner: self.monitor.clone(),
     }
+  }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
@@ -92,148 +92,148 @@ pub struct MonitorHandle(HMONITOR);
 unsafe impl Send for MonitorHandle {}
 
 unsafe extern "system" fn monitor_enum_proc(
-    hmonitor: HMONITOR,
-    _hdc: HDC,
-    _place: LPRECT,
-    data: LPARAM,
+  hmonitor: HMONITOR,
+  _hdc: HDC,
+  _place: LPRECT,
+  data: LPARAM,
 ) -> BOOL {
-    let monitors = data as *mut VecDeque<MonitorHandle>;
-    (*monitors).push_back(MonitorHandle::new(hmonitor));
-    TRUE // continue enumeration
+  let monitors = data as *mut VecDeque<MonitorHandle>;
+  (*monitors).push_back(MonitorHandle::new(hmonitor));
+  TRUE // continue enumeration
 }
 
 pub fn available_monitors() -> VecDeque<MonitorHandle> {
-    let mut monitors: VecDeque<MonitorHandle> = VecDeque::new();
-    unsafe {
-        winuser::EnumDisplayMonitors(
-            ptr::null_mut(),
-            ptr::null_mut(),
-            Some(monitor_enum_proc),
-            &mut monitors as *mut _ as LPARAM,
-        );
-    }
-    monitors
+  let mut monitors: VecDeque<MonitorHandle> = VecDeque::new();
+  unsafe {
+    winuser::EnumDisplayMonitors(
+      ptr::null_mut(),
+      ptr::null_mut(),
+      Some(monitor_enum_proc),
+      &mut monitors as *mut _ as LPARAM,
+    );
+  }
+  monitors
 }
 
 pub fn primary_monitor() -> MonitorHandle {
-    const ORIGIN: POINT = POINT { x: 0, y: 0 };
-    let hmonitor = unsafe { winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY) };
-    MonitorHandle::new(hmonitor)
+  const ORIGIN: POINT = POINT { x: 0, y: 0 };
+  let hmonitor = unsafe { winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY) };
+  MonitorHandle::new(hmonitor)
 }
 
 pub fn current_monitor(hwnd: HWND) -> MonitorHandle {
-    let hmonitor = unsafe { winuser::MonitorFromWindow(hwnd, winuser::MONITOR_DEFAULTTONEAREST) };
-    MonitorHandle::new(hmonitor)
+  let hmonitor = unsafe { winuser::MonitorFromWindow(hwnd, winuser::MONITOR_DEFAULTTONEAREST) };
+  MonitorHandle::new(hmonitor)
 }
 
 impl Window {
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        available_monitors()
-    }
+  pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+    available_monitors()
+  }
 
-    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
-        let monitor = primary_monitor();
-        Some(RootMonitorHandle { inner: monitor })
-    }
+  pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    let monitor = primary_monitor();
+    Some(RootMonitorHandle { inner: monitor })
+  }
 }
 
 pub(crate) fn get_monitor_info(hmonitor: HMONITOR) -> Result<winuser::MONITORINFOEXW, io::Error> {
-    let mut monitor_info: winuser::MONITORINFOEXW = unsafe { mem::zeroed() };
-    monitor_info.cbSize = mem::size_of::<winuser::MONITORINFOEXW>() as DWORD;
-    let status = unsafe {
-        winuser::GetMonitorInfoW(
-            hmonitor,
-            &mut monitor_info as *mut winuser::MONITORINFOEXW as *mut winuser::MONITORINFO,
-        )
-    };
-    if status == 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(monitor_info)
-    }
+  let mut monitor_info: winuser::MONITORINFOEXW = unsafe { mem::zeroed() };
+  monitor_info.cbSize = mem::size_of::<winuser::MONITORINFOEXW>() as DWORD;
+  let status = unsafe {
+    winuser::GetMonitorInfoW(
+      hmonitor,
+      &mut monitor_info as *mut winuser::MONITORINFOEXW as *mut winuser::MONITORINFO,
+    )
+  };
+  if status == 0 {
+    Err(io::Error::last_os_error())
+  } else {
+    Ok(monitor_info)
+  }
 }
 
 impl MonitorHandle {
-    pub(crate) fn new(hmonitor: HMONITOR) -> Self {
-        MonitorHandle(hmonitor)
-    }
+  pub(crate) fn new(hmonitor: HMONITOR) -> Self {
+    MonitorHandle(hmonitor)
+  }
 
-    #[inline]
-    pub fn name(&self) -> Option<String> {
+  #[inline]
+  pub fn name(&self) -> Option<String> {
+    let monitor_info = get_monitor_info(self.0).unwrap();
+    Some(util::wchar_ptr_to_string(monitor_info.szDevice.as_ptr()))
+  }
+
+  #[inline]
+  pub fn native_identifier(&self) -> String {
+    self.name().unwrap()
+  }
+
+  #[inline]
+  pub fn hmonitor(&self) -> HMONITOR {
+    self.0
+  }
+
+  #[inline]
+  pub fn size(&self) -> PhysicalSize<u32> {
+    let monitor_info = get_monitor_info(self.0).unwrap();
+    PhysicalSize {
+      width: (monitor_info.rcMonitor.right - monitor_info.rcMonitor.left) as u32,
+      height: (monitor_info.rcMonitor.bottom - monitor_info.rcMonitor.top) as u32,
+    }
+  }
+
+  #[inline]
+  pub fn position(&self) -> PhysicalPosition<i32> {
+    let monitor_info = get_monitor_info(self.0).unwrap();
+    PhysicalPosition {
+      x: monitor_info.rcMonitor.left,
+      y: monitor_info.rcMonitor.top,
+    }
+  }
+
+  #[inline]
+  pub fn scale_factor(&self) -> f64 {
+    dpi_to_scale_factor(get_monitor_dpi(self.0).unwrap_or(96))
+  }
+
+  #[inline]
+  pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
+    // EnumDisplaySettingsExW can return duplicate values (or some of the
+    // fields are probably changing, but we aren't looking at those fields
+    // anyway), so we're using a BTreeSet deduplicate
+    let mut modes = BTreeSet::new();
+    let mut i = 0;
+
+    loop {
+      unsafe {
         let monitor_info = get_monitor_info(self.0).unwrap();
-        Some(util::wchar_ptr_to_string(monitor_info.szDevice.as_ptr()))
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> String {
-        self.name().unwrap()
-    }
-
-    #[inline]
-    pub fn hmonitor(&self) -> HMONITOR {
-        self.0
-    }
-
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        let monitor_info = get_monitor_info(self.0).unwrap();
-        PhysicalSize {
-            width: (monitor_info.rcMonitor.right - monitor_info.rcMonitor.left) as u32,
-            height: (monitor_info.rcMonitor.bottom - monitor_info.rcMonitor.top) as u32,
+        let device_name = monitor_info.szDevice.as_ptr();
+        let mut mode: wingdi::DEVMODEW = mem::zeroed();
+        mode.dmSize = mem::size_of_val(&mode) as WORD;
+        if winuser::EnumDisplaySettingsExW(device_name, i, &mut mode, 0) == 0 {
+          break;
         }
+        i += 1;
+
+        const REQUIRED_FIELDS: DWORD = wingdi::DM_BITSPERPEL
+          | wingdi::DM_PELSWIDTH
+          | wingdi::DM_PELSHEIGHT
+          | wingdi::DM_DISPLAYFREQUENCY;
+        assert!(mode.dmFields & REQUIRED_FIELDS == REQUIRED_FIELDS);
+
+        modes.insert(RootVideoMode {
+          video_mode: VideoMode {
+            size: (mode.dmPelsWidth, mode.dmPelsHeight),
+            bit_depth: mode.dmBitsPerPel as u16,
+            refresh_rate: mode.dmDisplayFrequency as u16,
+            monitor: self.clone(),
+            native_video_mode: mode,
+          },
+        });
+      }
     }
 
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        let monitor_info = get_monitor_info(self.0).unwrap();
-        PhysicalPosition {
-            x: monitor_info.rcMonitor.left,
-            y: monitor_info.rcMonitor.top,
-        }
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        dpi_to_scale_factor(get_monitor_dpi(self.0).unwrap_or(96))
-    }
-
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
-        // EnumDisplaySettingsExW can return duplicate values (or some of the
-        // fields are probably changing, but we aren't looking at those fields
-        // anyway), so we're using a BTreeSet deduplicate
-        let mut modes = BTreeSet::new();
-        let mut i = 0;
-
-        loop {
-            unsafe {
-                let monitor_info = get_monitor_info(self.0).unwrap();
-                let device_name = monitor_info.szDevice.as_ptr();
-                let mut mode: wingdi::DEVMODEW = mem::zeroed();
-                mode.dmSize = mem::size_of_val(&mode) as WORD;
-                if winuser::EnumDisplaySettingsExW(device_name, i, &mut mode, 0) == 0 {
-                    break;
-                }
-                i += 1;
-
-                const REQUIRED_FIELDS: DWORD = wingdi::DM_BITSPERPEL
-                    | wingdi::DM_PELSWIDTH
-                    | wingdi::DM_PELSHEIGHT
-                    | wingdi::DM_DISPLAYFREQUENCY;
-                assert!(mode.dmFields & REQUIRED_FIELDS == REQUIRED_FIELDS);
-
-                modes.insert(RootVideoMode {
-                    video_mode: VideoMode {
-                        size: (mode.dmPelsWidth, mode.dmPelsHeight),
-                        bit_depth: mode.dmBitsPerPel as u16,
-                        refresh_rate: mode.dmDisplayFrequency as u16,
-                        monitor: self.clone(),
-                        native_video_mode: mode,
-                    },
-                });
-            }
-        }
-
-        modes.into_iter()
-    }
+    modes.into_iter()
+  }
 }

src/platform_impl/windows/raw_input.rs

@@ -1,221 +1,220 @@
 use std::{
-    mem::{self, size_of},
-    ptr,
+  mem::{self, size_of},
+  ptr,
 };
 
 use winapi::{
-    ctypes::wchar_t,
-    shared::{
-        hidusage::{HID_USAGE_GENERIC_KEYBOARD, HID_USAGE_GENERIC_MOUSE, HID_USAGE_PAGE_GENERIC},
-        minwindef::{TRUE, UINT, USHORT},
-        windef::HWND,
-    },
-    um::{
-        winnt::HANDLE,
-        winuser::{
-            self, HRAWINPUT, RAWINPUT, RAWINPUTDEVICE, RAWINPUTDEVICELIST, RAWINPUTHEADER,
-            RIDEV_DEVNOTIFY, RIDEV_INPUTSINK, RIDI_DEVICEINFO, RIDI_DEVICENAME, RID_DEVICE_INFO,
-            RID_DEVICE_INFO_HID, RID_DEVICE_INFO_KEYBOARD, RID_DEVICE_INFO_MOUSE, RID_INPUT,
-            RIM_TYPEHID, RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
-        },
+  ctypes::wchar_t,
+  shared::{
+    hidusage::{HID_USAGE_GENERIC_KEYBOARD, HID_USAGE_GENERIC_MOUSE, HID_USAGE_PAGE_GENERIC},
+    minwindef::{TRUE, UINT, USHORT},
+    windef::HWND,
+  },
+  um::{
+    winnt::HANDLE,
+    winuser::{
+      self, HRAWINPUT, RAWINPUT, RAWINPUTDEVICE, RAWINPUTDEVICELIST, RAWINPUTHEADER,
+      RIDEV_DEVNOTIFY, RIDEV_INPUTSINK, RIDI_DEVICEINFO, RIDI_DEVICENAME, RID_DEVICE_INFO,
+      RID_DEVICE_INFO_HID, RID_DEVICE_INFO_KEYBOARD, RID_DEVICE_INFO_MOUSE, RID_INPUT, RIM_TYPEHID,
+      RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
     },
+  },
 };
 
 use crate::{event::ElementState, platform_impl::platform::util};
 
 #[allow(dead_code)]
 pub fn get_raw_input_device_list() -> Option<Vec<RAWINPUTDEVICELIST>> {
-    let list_size = size_of::<RAWINPUTDEVICELIST>() as UINT;
+  let list_size = size_of::<RAWINPUTDEVICELIST>() as UINT;
 
-    let mut num_devices = 0;
-    let status =
-        unsafe { winuser::GetRawInputDeviceList(ptr::null_mut(), &mut num_devices, list_size) };
+  let mut num_devices = 0;
+  let status =
+    unsafe { winuser::GetRawInputDeviceList(ptr::null_mut(), &mut num_devices, list_size) };
 
-    if status == UINT::max_value() {
-        return None;
-    }
+  if status == UINT::max_value() {
+    return None;
+  }
 
-    let mut buffer = Vec::with_capacity(num_devices as _);
+  let mut buffer = Vec::with_capacity(num_devices as _);
 
-    let num_stored = unsafe {
-        winuser::GetRawInputDeviceList(buffer.as_ptr() as _, &mut num_devices, list_size)
-    };
+  let num_stored =
+    unsafe { winuser::GetRawInputDeviceList(buffer.as_ptr() as _, &mut num_devices, list_size) };
 
-    if num_stored == UINT::max_value() {
-        return None;
-    }
+  if num_stored == UINT::max_value() {
+    return None;
+  }
 
-    debug_assert_eq!(num_devices, num_stored);
+  debug_assert_eq!(num_devices, num_stored);
 
-    unsafe { buffer.set_len(num_devices as _) };
+  unsafe { buffer.set_len(num_devices as _) };
 
-    Some(buffer)
+  Some(buffer)
 }
 
 #[allow(dead_code)]
 pub enum RawDeviceInfo {
-    Mouse(RID_DEVICE_INFO_MOUSE),
-    Keyboard(RID_DEVICE_INFO_KEYBOARD),
-    Hid(RID_DEVICE_INFO_HID),
+  Mouse(RID_DEVICE_INFO_MOUSE),
+  Keyboard(RID_DEVICE_INFO_KEYBOARD),
+  Hid(RID_DEVICE_INFO_HID),
 }
 
 impl From<RID_DEVICE_INFO> for RawDeviceInfo {
-    fn from(info: RID_DEVICE_INFO) -> Self {
-        unsafe {
-            match info.dwType {
-                RIM_TYPEMOUSE => RawDeviceInfo::Mouse(*info.u.mouse()),
-                RIM_TYPEKEYBOARD => RawDeviceInfo::Keyboard(*info.u.keyboard()),
-                RIM_TYPEHID => RawDeviceInfo::Hid(*info.u.hid()),
-                _ => unreachable!(),
-            }
-        }
+  fn from(info: RID_DEVICE_INFO) -> Self {
+    unsafe {
+      match info.dwType {
+        RIM_TYPEMOUSE => RawDeviceInfo::Mouse(*info.u.mouse()),
+        RIM_TYPEKEYBOARD => RawDeviceInfo::Keyboard(*info.u.keyboard()),
+        RIM_TYPEHID => RawDeviceInfo::Hid(*info.u.hid()),
+        _ => unreachable!(),
+      }
     }
+  }
 }
 
 #[allow(dead_code)]
 pub fn get_raw_input_device_info(handle: HANDLE) -> Option<RawDeviceInfo> {
-    let mut info: RID_DEVICE_INFO = unsafe { mem::zeroed() };
-    let info_size = size_of::<RID_DEVICE_INFO>() as UINT;
+  let mut info: RID_DEVICE_INFO = unsafe { mem::zeroed() };
+  let info_size = size_of::<RID_DEVICE_INFO>() as UINT;
 
-    info.cbSize = info_size;
+  info.cbSize = info_size;
 
-    let mut minimum_size = 0;
-    let status = unsafe {
-        winuser::GetRawInputDeviceInfoW(
-            handle,
-            RIDI_DEVICEINFO,
-            &mut info as *mut _ as _,
-            &mut minimum_size,
-        )
-    };
+  let mut minimum_size = 0;
+  let status = unsafe {
+    winuser::GetRawInputDeviceInfoW(
+      handle,
+      RIDI_DEVICEINFO,
+      &mut info as *mut _ as _,
+      &mut minimum_size,
+    )
+  };
 
-    if status == UINT::max_value() || status == 0 {
-        return None;
-    }
+  if status == UINT::max_value() || status == 0 {
+    return None;
+  }
 
-    debug_assert_eq!(info_size, status);
+  debug_assert_eq!(info_size, status);
 
-    Some(info.into())
+  Some(info.into())
 }
 
 pub fn get_raw_input_device_name(handle: HANDLE) -> Option<String> {
-    let mut minimum_size = 0;
-    let status = unsafe {
-        winuser::GetRawInputDeviceInfoW(handle, RIDI_DEVICENAME, ptr::null_mut(), &mut minimum_size)
-    };
+  let mut minimum_size = 0;
+  let status = unsafe {
+    winuser::GetRawInputDeviceInfoW(handle, RIDI_DEVICENAME, ptr::null_mut(), &mut minimum_size)
+  };
 
-    if status != 0 {
-        return None;
-    }
+  if status != 0 {
+    return None;
+  }
 
-    let mut name: Vec<wchar_t> = Vec::with_capacity(minimum_size as _);
+  let mut name: Vec<wchar_t> = Vec::with_capacity(minimum_size as _);
 
-    let status = unsafe {
-        winuser::GetRawInputDeviceInfoW(
-            handle,
-            RIDI_DEVICENAME,
-            name.as_ptr() as _,
-            &mut minimum_size,
-        )
-    };
+  let status = unsafe {
+    winuser::GetRawInputDeviceInfoW(
+      handle,
+      RIDI_DEVICENAME,
+      name.as_ptr() as _,
+      &mut minimum_size,
+    )
+  };
 
-    if status == UINT::max_value() || status == 0 {
-        return None;
-    }
+  if status == UINT::max_value() || status == 0 {
+    return None;
+  }
 
-    debug_assert_eq!(minimum_size, status);
+  debug_assert_eq!(minimum_size, status);
 
-    unsafe { name.set_len(minimum_size as _) };
+  unsafe { name.set_len(minimum_size as _) };
 
-    Some(util::wchar_to_string(&name))
+  Some(util::wchar_to_string(&name))
 }
 
 pub fn register_raw_input_devices(devices: &[RAWINPUTDEVICE]) -> bool {
-    let device_size = size_of::<RAWINPUTDEVICE>() as UINT;
+  let device_size = size_of::<RAWINPUTDEVICE>() as UINT;
 
-    let success = unsafe {
-        winuser::RegisterRawInputDevices(devices.as_ptr() as _, devices.len() as _, device_size)
-    };
+  let success = unsafe {
+    winuser::RegisterRawInputDevices(devices.as_ptr() as _, devices.len() as _, device_size)
+  };
 
-    success == TRUE
+  success == TRUE
 }
 
 pub fn register_all_mice_and_keyboards_for_raw_input(window_handle: HWND) -> bool {
-    // RIDEV_DEVNOTIFY: receive hotplug events
-    // RIDEV_INPUTSINK: receive events even if we're not in the foreground
-    let flags = RIDEV_DEVNOTIFY | RIDEV_INPUTSINK;
+  // RIDEV_DEVNOTIFY: receive hotplug events
+  // RIDEV_INPUTSINK: receive events even if we're not in the foreground
+  let flags = RIDEV_DEVNOTIFY | RIDEV_INPUTSINK;
 
-    let devices: [RAWINPUTDEVICE; 2] = [
-        RAWINPUTDEVICE {
-            usUsagePage: HID_USAGE_PAGE_GENERIC,
-            usUsage: HID_USAGE_GENERIC_MOUSE,
-            dwFlags: flags,
-            hwndTarget: window_handle,
-        },
-        RAWINPUTDEVICE {
-            usUsagePage: HID_USAGE_PAGE_GENERIC,
-            usUsage: HID_USAGE_GENERIC_KEYBOARD,
-            dwFlags: flags,
-            hwndTarget: window_handle,
-        },
-    ];
+  let devices: [RAWINPUTDEVICE; 2] = [
+    RAWINPUTDEVICE {
+      usUsagePage: HID_USAGE_PAGE_GENERIC,
+      usUsage: HID_USAGE_GENERIC_MOUSE,
+      dwFlags: flags,
+      hwndTarget: window_handle,
+    },
+    RAWINPUTDEVICE {
+      usUsagePage: HID_USAGE_PAGE_GENERIC,
+      usUsage: HID_USAGE_GENERIC_KEYBOARD,
+      dwFlags: flags,
+      hwndTarget: window_handle,
+    },
+  ];
 
-    register_raw_input_devices(&devices)
+  register_raw_input_devices(&devices)
 }
 
 pub fn get_raw_input_data(handle: HRAWINPUT) -> Option<RAWINPUT> {
-    let mut data: RAWINPUT = unsafe { mem::zeroed() };
-    let mut data_size = size_of::<RAWINPUT>() as UINT;
-    let header_size = size_of::<RAWINPUTHEADER>() as UINT;
+  let mut data: RAWINPUT = unsafe { mem::zeroed() };
+  let mut data_size = size_of::<RAWINPUT>() as UINT;
+  let header_size = size_of::<RAWINPUTHEADER>() as UINT;
 
-    let status = unsafe {
-        winuser::GetRawInputData(
-            handle,
-            RID_INPUT,
-            &mut data as *mut _ as _,
-            &mut data_size,
-            header_size,
-        )
-    };
+  let status = unsafe {
+    winuser::GetRawInputData(
+      handle,
+      RID_INPUT,
+      &mut data as *mut _ as _,
+      &mut data_size,
+      header_size,
+    )
+  };
 
-    if status == UINT::max_value() || status == 0 {
-        return None;
-    }
+  if status == UINT::max_value() || status == 0 {
+    return None;
+  }
 
-    Some(data)
+  Some(data)
 }
 
 fn button_flags_to_element_state(
-    button_flags: USHORT,
-    down_flag: USHORT,
-    up_flag: USHORT,
+  button_flags: USHORT,
+  down_flag: USHORT,
+  up_flag: USHORT,
 ) -> Option<ElementState> {
-    // We assume the same button won't be simultaneously pressed and released.
-    if util::has_flag(button_flags, down_flag) {
-        Some(ElementState::Pressed)
-    } else if util::has_flag(button_flags, up_flag) {
-        Some(ElementState::Released)
-    } else {
-        None
-    }
+  // We assume the same button won't be simultaneously pressed and released.
+  if util::has_flag(button_flags, down_flag) {
+    Some(ElementState::Pressed)
+  } else if util::has_flag(button_flags, up_flag) {
+    Some(ElementState::Released)
+  } else {
+    None
+  }
 }
 
 pub fn get_raw_mouse_button_state(button_flags: USHORT) -> [Option<ElementState>; 3] {
-    [
-        button_flags_to_element_state(
-            button_flags,
-            winuser::RI_MOUSE_LEFT_BUTTON_DOWN,
-            winuser::RI_MOUSE_LEFT_BUTTON_UP,
-        ),
-        button_flags_to_element_state(
-            button_flags,
-            winuser::RI_MOUSE_MIDDLE_BUTTON_DOWN,
-            winuser::RI_MOUSE_MIDDLE_BUTTON_UP,
-        ),
-        button_flags_to_element_state(
-            button_flags,
-            winuser::RI_MOUSE_RIGHT_BUTTON_DOWN,
-            winuser::RI_MOUSE_RIGHT_BUTTON_UP,
-        ),
-    ]
+  [
+    button_flags_to_element_state(
+      button_flags,
+      winuser::RI_MOUSE_LEFT_BUTTON_DOWN,
+      winuser::RI_MOUSE_LEFT_BUTTON_UP,
+    ),
+    button_flags_to_element_state(
+      button_flags,
+      winuser::RI_MOUSE_MIDDLE_BUTTON_DOWN,
+      winuser::RI_MOUSE_MIDDLE_BUTTON_UP,
+    ),
+    button_flags_to_element_state(
+      button_flags,
+      winuser::RI_MOUSE_RIGHT_BUTTON_DOWN,
+      winuser::RI_MOUSE_RIGHT_BUTTON_UP,
+    ),
+  ]
 }

src/platform_impl/windows/util.rs

@@ -1,298 +1,292 @@
 use std::{
-    io, mem,
-    ops::BitAnd,
-    os::raw::c_void,
-    ptr, slice,
-    sync::atomic::{AtomicBool, Ordering},
+  io, mem,
+  ops::BitAnd,
+  os::raw::c_void,
+  ptr, slice,
+  sync::atomic::{AtomicBool, Ordering},
 };
 
 use crate::{dpi::PhysicalSize, window::CursorIcon};
 use winapi::{
-    ctypes::wchar_t,
-    shared::{
-        minwindef::{BOOL, DWORD, UINT},
-        windef::{DPI_AWARENESS_CONTEXT, HMONITOR, HWND, LPRECT, RECT},
-    },
-    um::{
-        libloaderapi::{GetProcAddress, LoadLibraryA},
-        shellscalingapi::{MONITOR_DPI_TYPE, PROCESS_DPI_AWARENESS},
-        winbase::lstrlenW,
-        winnt::{HRESULT, LONG, LPCSTR},
-        winuser,
-    },
+  ctypes::wchar_t,
+  shared::{
+    minwindef::{BOOL, DWORD, UINT},
+    windef::{DPI_AWARENESS_CONTEXT, HMONITOR, HWND, LPRECT, RECT},
+  },
+  um::{
+    libloaderapi::{GetProcAddress, LoadLibraryA},
+    shellscalingapi::{MONITOR_DPI_TYPE, PROCESS_DPI_AWARENESS},
+    winbase::lstrlenW,
+    winnt::{HRESULT, LONG, LPCSTR},
+    winuser,
+  },
 };
 
 pub fn has_flag<T>(bitset: T, flag: T) -> bool
 where
-    T: Copy + PartialEq + BitAnd<T, Output = T>,
+  T: Copy + PartialEq + BitAnd<T, Output = T>,
 {
-    bitset & flag == flag
+  bitset & flag == flag
 }
 
 pub fn wchar_to_string(wchar: &[wchar_t]) -> String {
-    String::from_utf16_lossy(wchar).to_string()
+  String::from_utf16_lossy(wchar).to_string()
 }
 
 pub fn wchar_ptr_to_string(wchar: *const wchar_t) -> String {
-    let len = unsafe { lstrlenW(wchar) } as usize;
-    let wchar_slice = unsafe { slice::from_raw_parts(wchar, len) };
-    wchar_to_string(wchar_slice)
+  let len = unsafe { lstrlenW(wchar) } as usize;
+  let wchar_slice = unsafe { slice::from_raw_parts(wchar, len) };
+  wchar_to_string(wchar_slice)
 }
 
 pub unsafe fn status_map<T, F: FnMut(&mut T) -> BOOL>(mut fun: F) -> Option<T> {
-    let mut data: T = mem::zeroed();
-    if fun(&mut data) != 0 {
-        Some(data)
-    } else {
-        None
-    }
+  let mut data: T = mem::zeroed();
+  if fun(&mut data) != 0 {
+    Some(data)
+  } else {
+    None
+  }
 }
 
 fn win_to_err<F: FnOnce() -> BOOL>(f: F) -> Result<(), io::Error> {
-    if f() != 0 {
-        Ok(())
-    } else {
-        Err(io::Error::last_os_error())
-    }
+  if f() != 0 {
+    Ok(())
+  } else {
+    Err(io::Error::last_os_error())
+  }
 }
 
 pub fn get_window_rect(hwnd: HWND) -> Option<RECT> {
-    unsafe { status_map(|rect| winuser::GetWindowRect(hwnd, rect)) }
+  unsafe { status_map(|rect| winuser::GetWindowRect(hwnd, rect)) }
 }
 
 pub fn get_client_rect(hwnd: HWND) -> Result<RECT, io::Error> {
-    unsafe {
-        let mut rect = mem::zeroed();
-        let mut top_left = mem::zeroed();
+  unsafe {
+    let mut rect = mem::zeroed();
+    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;
+    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)
-    }
+    Ok(rect)
+  }
 }
 
 pub fn adjust_size(hwnd: HWND, size: PhysicalSize<u32>) -> PhysicalSize<u32> {
-    let (width, height): (u32, u32) = size.into();
-    let rect = RECT {
-        left: 0,
-        right: width as LONG,
-        top: 0,
-        bottom: height as LONG,
-    };
-    let rect = adjust_window_rect(hwnd, rect).unwrap_or(rect);
-    PhysicalSize::new((rect.right - rect.left) as _, (rect.bottom - rect.top) as _)
+  let (width, height): (u32, u32) = size.into();
+  let rect = RECT {
+    left: 0,
+    right: width as LONG,
+    top: 0,
+    bottom: height as LONG,
+  };
+  let rect = adjust_window_rect(hwnd, rect).unwrap_or(rect);
+  PhysicalSize::new((rect.right - rect.left) as _, (rect.bottom - rect.top) as _)
 }
 
 pub(crate) fn set_inner_size_physical(window: HWND, x: u32, y: u32) {
-    unsafe {
-        let rect = adjust_window_rect(
-            window,
-            RECT {
-                top: 0,
-                left: 0,
-                bottom: y as LONG,
-                right: x as LONG,
-            },
-        )
-        .expect("adjust_window_rect failed");
+  unsafe {
+    let rect = adjust_window_rect(
+      window,
+      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 _;
-        let outer_y = (rect.top - rect.bottom).abs() as _;
-        winuser::SetWindowPos(
-            window,
-            ptr::null_mut(),
-            0,
-            0,
-            outer_x,
-            outer_y,
-            winuser::SWP_ASYNCWINDOWPOS
-                | winuser::SWP_NOZORDER
-                | winuser::SWP_NOREPOSITION
-                | winuser::SWP_NOMOVE
-                | winuser::SWP_NOACTIVATE,
-        );
-        winuser::InvalidateRgn(window, ptr::null_mut(), 0);
-    }
+    let outer_x = (rect.right - rect.left).abs() as _;
+    let outer_y = (rect.top - rect.bottom).abs() as _;
+    winuser::SetWindowPos(
+      window,
+      ptr::null_mut(),
+      0,
+      0,
+      outer_x,
+      outer_y,
+      winuser::SWP_ASYNCWINDOWPOS
+        | winuser::SWP_NOZORDER
+        | winuser::SWP_NOREPOSITION
+        | winuser::SWP_NOMOVE
+        | winuser::SWP_NOACTIVATE,
+    );
+    winuser::InvalidateRgn(window, ptr::null_mut(), 0);
+  }
 }
 
 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)
-    }
+  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,
+  hwnd: HWND,
+  style: DWORD,
+  style_ex: DWORD,
+  rect: RECT,
 ) -> Option<RECT> {
-    unsafe {
-        status_map(|r| {
-            *r = rect;
+  unsafe {
+    status_map(|r| {
+      *r = rect;
 
-            let b_menu = !winuser::GetMenu(hwnd).is_null() as BOOL;
-            if let (Some(get_dpi_for_window), Some(adjust_window_rect_ex_for_dpi)) =
-                (*GET_DPI_FOR_WINDOW, *ADJUST_WINDOW_RECT_EX_FOR_DPI)
-            {
-                let dpi = get_dpi_for_window(hwnd);
-                adjust_window_rect_ex_for_dpi(r, style as _, b_menu, style_ex as _, dpi)
-            } else {
-                winuser::AdjustWindowRectEx(r, style as _, b_menu, style_ex as _)
-            }
-        })
-    }
+      let b_menu = !winuser::GetMenu(hwnd).is_null() as BOOL;
+      if let (Some(get_dpi_for_window), Some(adjust_window_rect_ex_for_dpi)) =
+        (*GET_DPI_FOR_WINDOW, *ADJUST_WINDOW_RECT_EX_FOR_DPI)
+      {
+        let dpi = get_dpi_for_window(hwnd);
+        adjust_window_rect_ex_for_dpi(r, style as _, b_menu, style_ex as _, dpi)
+      } else {
+        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) };
-    }
+  static HIDDEN: AtomicBool = AtomicBool::new(false);
+  let changed = HIDDEN.swap(hidden, Ordering::SeqCst) ^ hidden;
+  if changed {
+    unsafe { winuser::ShowCursor(!hidden as BOOL) };
+  }
 }
 
 pub fn get_cursor_clip() -> Result<RECT, io::Error> {
-    unsafe {
-        let mut rect: RECT = mem::zeroed();
-        win_to_err(|| winuser::GetClipCursor(&mut rect)).map(|_| rect)
-    }
+  unsafe {
+    let mut rect: RECT = mem::zeroed();
+    win_to_err(|| winuser::GetClipCursor(&mut rect)).map(|_| rect)
+  }
 }
 
 /// Sets the cursor's clip rect.
 ///
 /// Note that calling this will automatically dispatch a `WM_MOUSEMOVE` event.
 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))
-    }
+  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 get_desktop_rect() -> RECT {
-    unsafe {
-        let left = winuser::GetSystemMetrics(winuser::SM_XVIRTUALSCREEN);
-        let top = winuser::GetSystemMetrics(winuser::SM_YVIRTUALSCREEN);
-        RECT {
-            left,
-            top,
-            right: left + winuser::GetSystemMetrics(winuser::SM_CXVIRTUALSCREEN),
-            bottom: top + winuser::GetSystemMetrics(winuser::SM_CYVIRTUALSCREEN),
-        }
+  unsafe {
+    let left = winuser::GetSystemMetrics(winuser::SM_XVIRTUALSCREEN);
+    let top = winuser::GetSystemMetrics(winuser::SM_YVIRTUALSCREEN);
+    RECT {
+      left,
+      top,
+      right: left + winuser::GetSystemMetrics(winuser::SM_CXVIRTUALSCREEN),
+      bottom: top + winuser::GetSystemMetrics(winuser::SM_CYVIRTUALSCREEN),
     }
+  }
 }
 
 pub fn is_focused(window: HWND) -> bool {
-    window == unsafe { winuser::GetActiveWindow() }
+  window == unsafe { winuser::GetActiveWindow() }
 }
 
 impl CursorIcon {
-    pub(crate) fn to_windows_cursor(self) -> *const wchar_t {
-        match self {
-            CursorIcon::Arrow | CursorIcon::Default => winuser::IDC_ARROW,
-            CursorIcon::Hand => winuser::IDC_HAND,
-            CursorIcon::Crosshair => winuser::IDC_CROSS,
-            CursorIcon::Text | CursorIcon::VerticalText => winuser::IDC_IBEAM,
-            CursorIcon::NotAllowed | CursorIcon::NoDrop => winuser::IDC_NO,
-            CursorIcon::Grab | CursorIcon::Grabbing | CursorIcon::Move | CursorIcon::AllScroll => {
-                winuser::IDC_SIZEALL
-            }
-            CursorIcon::EResize
-            | CursorIcon::WResize
-            | CursorIcon::EwResize
-            | CursorIcon::ColResize => winuser::IDC_SIZEWE,
-            CursorIcon::NResize
-            | CursorIcon::SResize
-            | CursorIcon::NsResize
-            | CursorIcon::RowResize => winuser::IDC_SIZENS,
-            CursorIcon::NeResize | CursorIcon::SwResize | CursorIcon::NeswResize => {
-                winuser::IDC_SIZENESW
-            }
-            CursorIcon::NwResize | CursorIcon::SeResize | CursorIcon::NwseResize => {
-                winuser::IDC_SIZENWSE
-            }
-            CursorIcon::Wait => winuser::IDC_WAIT,
-            CursorIcon::Progress => winuser::IDC_APPSTARTING,
-            CursorIcon::Help => winuser::IDC_HELP,
-            _ => winuser::IDC_ARROW, // use arrow for the missing cases.
-        }
+  pub(crate) fn to_windows_cursor(self) -> *const wchar_t {
+    match self {
+      CursorIcon::Arrow | CursorIcon::Default => winuser::IDC_ARROW,
+      CursorIcon::Hand => winuser::IDC_HAND,
+      CursorIcon::Crosshair => winuser::IDC_CROSS,
+      CursorIcon::Text | CursorIcon::VerticalText => winuser::IDC_IBEAM,
+      CursorIcon::NotAllowed | CursorIcon::NoDrop => winuser::IDC_NO,
+      CursorIcon::Grab | CursorIcon::Grabbing | CursorIcon::Move | CursorIcon::AllScroll => {
+        winuser::IDC_SIZEALL
+      }
+      CursorIcon::EResize | CursorIcon::WResize | CursorIcon::EwResize | CursorIcon::ColResize => {
+        winuser::IDC_SIZEWE
+      }
+      CursorIcon::NResize | CursorIcon::SResize | CursorIcon::NsResize | CursorIcon::RowResize => {
+        winuser::IDC_SIZENS
+      }
+      CursorIcon::NeResize | CursorIcon::SwResize | CursorIcon::NeswResize => winuser::IDC_SIZENESW,
+      CursorIcon::NwResize | CursorIcon::SeResize | CursorIcon::NwseResize => winuser::IDC_SIZENWSE,
+      CursorIcon::Wait => winuser::IDC_WAIT,
+      CursorIcon::Progress => winuser::IDC_APPSTARTING,
+      CursorIcon::Help => winuser::IDC_HELP,
+      _ => winuser::IDC_ARROW, // use arrow for the missing cases.
     }
+  }
 }
 
 // Helper function to dynamically load function pointer.
 // `library` and `function` must be zero-terminated.
 pub(super) fn get_function_impl(library: &str, function: &str) -> Option<*const c_void> {
-    assert_eq!(library.chars().last(), Some('\0'));
-    assert_eq!(function.chars().last(), Some('\0'));
+  assert_eq!(library.chars().last(), Some('\0'));
+  assert_eq!(function.chars().last(), Some('\0'));
 
-    // Library names we will use are ASCII so we can use the A version to avoid string conversion.
-    let module = unsafe { LoadLibraryA(library.as_ptr() as LPCSTR) };
-    if module.is_null() {
-        return None;
-    }
+  // Library names we will use are ASCII so we can use the A version to avoid string conversion.
+  let module = unsafe { LoadLibraryA(library.as_ptr() as LPCSTR) };
+  if module.is_null() {
+    return None;
+  }
 
-    let function_ptr = unsafe { GetProcAddress(module, function.as_ptr() as LPCSTR) };
-    if function_ptr.is_null() {
-        return None;
-    }
+  let function_ptr = unsafe { GetProcAddress(module, function.as_ptr() as LPCSTR) };
+  if function_ptr.is_null() {
+    return None;
+  }
 
-    Some(function_ptr as _)
+  Some(function_ptr as _)
 }
 
 macro_rules! get_function {
-    ($lib:expr, $func:ident) => {
-        crate::platform_impl::platform::util::get_function_impl(
-            concat!($lib, '\0'),
-            concat!(stringify!($func), '\0'),
-        )
-        .map(|f| unsafe { std::mem::transmute::<*const _, $func>(f) })
-    };
+  ($lib:expr, $func:ident) => {
+    crate::platform_impl::platform::util::get_function_impl(
+      concat!($lib, '\0'),
+      concat!(stringify!($func), '\0'),
+    )
+    .map(|f| unsafe { std::mem::transmute::<*const _, $func>(f) })
+  };
 }
 
 pub type SetProcessDPIAware = unsafe extern "system" fn() -> BOOL;
 pub type SetProcessDpiAwareness =
-    unsafe extern "system" fn(value: PROCESS_DPI_AWARENESS) -> HRESULT;
+  unsafe extern "system" fn(value: PROCESS_DPI_AWARENESS) -> HRESULT;
 pub type SetProcessDpiAwarenessContext =
-    unsafe extern "system" fn(value: DPI_AWARENESS_CONTEXT) -> BOOL;
+  unsafe extern "system" fn(value: DPI_AWARENESS_CONTEXT) -> BOOL;
 pub type GetDpiForWindow = unsafe extern "system" fn(hwnd: HWND) -> UINT;
 pub type GetDpiForMonitor = unsafe extern "system" fn(
-    hmonitor: HMONITOR,
-    dpi_type: MONITOR_DPI_TYPE,
-    dpi_x: *mut UINT,
-    dpi_y: *mut UINT,
+  hmonitor: HMONITOR,
+  dpi_type: MONITOR_DPI_TYPE,
+  dpi_x: *mut UINT,
+  dpi_y: *mut UINT,
 ) -> HRESULT;
 pub type EnableNonClientDpiScaling = unsafe extern "system" fn(hwnd: HWND) -> BOOL;
 pub type AdjustWindowRectExForDpi = unsafe extern "system" fn(
-    rect: LPRECT,
-    dwStyle: DWORD,
-    bMenu: BOOL,
-    dwExStyle: DWORD,
-    dpi: UINT,
+  rect: LPRECT,
+  dwStyle: DWORD,
+  bMenu: BOOL,
+  dwExStyle: DWORD,
+  dpi: UINT,
 ) -> BOOL;
 
 lazy_static! {
-    pub static ref GET_DPI_FOR_WINDOW: Option<GetDpiForWindow> =
-        get_function!("user32.dll", GetDpiForWindow);
-    pub static ref ADJUST_WINDOW_RECT_EX_FOR_DPI: Option<AdjustWindowRectExForDpi> =
-        get_function!("user32.dll", AdjustWindowRectExForDpi);
-    pub static ref GET_DPI_FOR_MONITOR: Option<GetDpiForMonitor> =
-        get_function!("shcore.dll", GetDpiForMonitor);
-    pub static ref ENABLE_NON_CLIENT_DPI_SCALING: Option<EnableNonClientDpiScaling> =
-        get_function!("user32.dll", EnableNonClientDpiScaling);
-    pub static ref SET_PROCESS_DPI_AWARENESS_CONTEXT: Option<SetProcessDpiAwarenessContext> =
-        get_function!("user32.dll", SetProcessDpiAwarenessContext);
-    pub static ref SET_PROCESS_DPI_AWARENESS: Option<SetProcessDpiAwareness> =
-        get_function!("shcore.dll", SetProcessDpiAwareness);
-    pub static ref SET_PROCESS_DPI_AWARE: Option<SetProcessDPIAware> =
-        get_function!("user32.dll", SetProcessDPIAware);
+  pub static ref GET_DPI_FOR_WINDOW: Option<GetDpiForWindow> =
+    get_function!("user32.dll", GetDpiForWindow);
+  pub static ref ADJUST_WINDOW_RECT_EX_FOR_DPI: Option<AdjustWindowRectExForDpi> =
+    get_function!("user32.dll", AdjustWindowRectExForDpi);
+  pub static ref GET_DPI_FOR_MONITOR: Option<GetDpiForMonitor> =
+    get_function!("shcore.dll", GetDpiForMonitor);
+  pub static ref ENABLE_NON_CLIENT_DPI_SCALING: Option<EnableNonClientDpiScaling> =
+    get_function!("user32.dll", EnableNonClientDpiScaling);
+  pub static ref SET_PROCESS_DPI_AWARENESS_CONTEXT: Option<SetProcessDpiAwarenessContext> =
+    get_function!("user32.dll", SetProcessDpiAwarenessContext);
+  pub static ref SET_PROCESS_DPI_AWARENESS: Option<SetProcessDpiAwareness> =
+    get_function!("shcore.dll", SetProcessDpiAwareness);
+  pub static ref SET_PROCESS_DPI_AWARE: Option<SetProcessDPIAware> =
+    get_function!("user32.dll", SetProcessDPIAware);
 }

src/platform_impl/windows/window_state.rs

@@ -1,53 +1,53 @@
 use crate::{
-    dpi::{PhysicalPosition, Size},
-    event::ModifiersState,
-    icon::Icon,
-    platform_impl::platform::{event_loop, util},
-    window::{CursorIcon, Fullscreen, Theme, WindowAttributes},
+  dpi::{PhysicalPosition, Size},
+  event::ModifiersState,
+  icon::Icon,
+  platform_impl::platform::{event_loop, util},
+  window::{CursorIcon, Fullscreen, Theme, WindowAttributes},
 };
 use parking_lot::MutexGuard;
 use std::{io, ptr};
 use winapi::{
-    shared::{
-        minwindef::DWORD,
-        windef::{HWND, RECT},
-    },
-    um::winuser,
+  shared::{
+    minwindef::DWORD,
+    windef::{HWND, RECT},
+  },
+  um::winuser,
 };
 
 /// Contains information about states and the window that the callback is going to use.
 pub struct WindowState {
-    pub mouse: MouseProperties,
+  pub mouse: MouseProperties,
 
-    /// Used by `WM_GETMINMAXINFO`.
-    pub min_size: Option<Size>,
-    pub max_size: Option<Size>,
+  /// Used by `WM_GETMINMAXINFO`.
+  pub min_size: Option<Size>,
+  pub max_size: Option<Size>,
 
-    pub window_icon: Option<Icon>,
-    pub taskbar_icon: Option<Icon>,
+  pub window_icon: Option<Icon>,
+  pub taskbar_icon: Option<Icon>,
 
-    pub saved_window: Option<SavedWindow>,
-    pub scale_factor: f64,
+  pub saved_window: Option<SavedWindow>,
+  pub scale_factor: f64,
 
-    pub modifiers_state: ModifiersState,
-    pub fullscreen: Option<Fullscreen>,
-    pub current_theme: Theme,
-    pub preferred_theme: Option<Theme>,
-    pub high_surrogate: Option<u16>,
-    pub window_flags: WindowFlags,
+  pub modifiers_state: ModifiersState,
+  pub fullscreen: Option<Fullscreen>,
+  pub current_theme: Theme,
+  pub preferred_theme: Option<Theme>,
+  pub high_surrogate: Option<u16>,
+  pub window_flags: WindowFlags,
 }
 
 #[derive(Clone)]
 pub struct SavedWindow {
-    pub placement: winuser::WINDOWPLACEMENT,
+  pub placement: winuser::WINDOWPLACEMENT,
 }
 
 #[derive(Clone)]
 pub struct MouseProperties {
-    pub cursor: CursorIcon,
-    pub capture_count: u32,
-    cursor_flags: CursorFlags,
-    pub last_position: Option<PhysicalPosition<f64>>,
+  pub cursor: CursorIcon,
+  pub capture_count: u32,
+  cursor_flags: CursorFlags,
+  pub last_position: Option<PhysicalPosition<f64>>,
 }
 
 bitflags! {
@@ -93,284 +93,284 @@ bitflags! {
 }
 
 impl WindowState {
-    pub fn new(
-        attributes: &WindowAttributes,
-        taskbar_icon: Option<Icon>,
-        scale_factor: f64,
-        current_theme: Theme,
-        preferred_theme: Option<Theme>,
-    ) -> WindowState {
-        WindowState {
-            mouse: MouseProperties {
-                cursor: CursorIcon::default(),
-                capture_count: 0,
-                cursor_flags: CursorFlags::empty(),
-                last_position: None,
-            },
+  pub fn new(
+    attributes: &WindowAttributes,
+    taskbar_icon: Option<Icon>,
+    scale_factor: f64,
+    current_theme: Theme,
+    preferred_theme: Option<Theme>,
+  ) -> WindowState {
+    WindowState {
+      mouse: MouseProperties {
+        cursor: CursorIcon::default(),
+        capture_count: 0,
+        cursor_flags: CursorFlags::empty(),
+        last_position: None,
+      },
 
-            min_size: attributes.min_inner_size,
-            max_size: attributes.max_inner_size,
+      min_size: attributes.min_inner_size,
+      max_size: attributes.max_inner_size,
 
-            window_icon: attributes.window_icon.clone(),
-            taskbar_icon,
+      window_icon: attributes.window_icon.clone(),
+      taskbar_icon,
 
-            saved_window: None,
-            scale_factor,
+      saved_window: None,
+      scale_factor,
 
-            modifiers_state: ModifiersState::default(),
-            fullscreen: None,
-            current_theme,
-            preferred_theme,
-            high_surrogate: None,
-            window_flags: WindowFlags::empty(),
-        }
+      modifiers_state: ModifiersState::default(),
+      fullscreen: None,
+      current_theme,
+      preferred_theme,
+      high_surrogate: None,
+      window_flags: WindowFlags::empty(),
     }
+  }
 
-    pub fn window_flags(&self) -> WindowFlags {
-        self.window_flags
-    }
+  pub fn window_flags(&self) -> WindowFlags {
+    self.window_flags
+  }
 
-    pub fn set_window_flags<F>(mut this: MutexGuard<'_, Self>, window: HWND, f: F)
-    where
-        F: FnOnce(&mut WindowFlags),
-    {
-        let old_flags = this.window_flags;
-        f(&mut this.window_flags);
-        let new_flags = this.window_flags;
+  pub fn set_window_flags<F>(mut this: MutexGuard<'_, Self>, window: HWND, f: F)
+  where
+    F: FnOnce(&mut WindowFlags),
+  {
+    let old_flags = this.window_flags;
+    f(&mut this.window_flags);
+    let new_flags = this.window_flags;
 
-        drop(this);
-        old_flags.apply_diff(window, new_flags);
-    }
+    drop(this);
+    old_flags.apply_diff(window, new_flags);
+  }
 
-    pub fn set_window_flags_in_place<F>(&mut self, f: F)
-    where
-        F: FnOnce(&mut WindowFlags),
-    {
-        f(&mut self.window_flags);
-    }
+  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 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);
+      }
     }
 
-    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(())
-    }
+    Ok(())
+  }
 }
 
 impl WindowFlags {
-    fn mask(mut self) -> WindowFlags {
-        if self.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN) {
-            self |= WindowFlags::EXCLUSIVE_FULLSCREEN_OR_MASK;
-        }
-        if !self.contains(WindowFlags::VISIBLE) {
-            self &= WindowFlags::INVISIBLE_AND_MASK;
-        }
-        if !self.contains(WindowFlags::DECORATIONS) {
-            self &= WindowFlags::NO_DECORATIONS_AND_MASK;
-        }
-        self
+  fn mask(mut self) -> WindowFlags {
+    if self.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN) {
+      self |= WindowFlags::EXCLUSIVE_FULLSCREEN_OR_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::CHILD) {
+      style |= WS_CHILD; // This is incompatible with WS_POPUP if that gets added eventually.
+    }
+    if self.contains(WindowFlags::POPUP) {
+      style |= WS_POPUP;
+    }
+    if self.contains(WindowFlags::MINIMIZED) {
+      style |= WS_MINIMIZE;
+    }
+    if self.contains(WindowFlags::MAXIMIZED) {
+      style |= WS_MAXIMIZE;
     }
 
-    pub fn to_window_styles(self) -> (DWORD, DWORD) {
-        use winapi::um::winuser::*;
+    style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU;
+    style_ex |= WS_EX_ACCEPTFILES;
 
-        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::CHILD) {
-            style |= WS_CHILD; // This is incompatible with WS_POPUP if that gets added eventually.
-        }
-        if self.contains(WindowFlags::POPUP) {
-            style |= WS_POPUP;
-        }
-        if self.contains(WindowFlags::MINIMIZED) {
-            style |= WS_MINIMIZE;
-        }
-        if self.contains(WindowFlags::MAXIMIZED) {
-            style |= WS_MAXIMIZE;
-        }
-
-        style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU;
-        style_ex |= WS_EX_ACCEPTFILES;
-
-        if self.intersects(
-            WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN | WindowFlags::MARKER_BORDERLESS_FULLSCREEN,
-        ) {
-            style &= !WS_OVERLAPPEDWINDOW;
-        }
-
-        (style, style_ex)
+    if self.intersects(
+      WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN | WindowFlags::MARKER_BORDERLESS_FULLSCREEN,
+    ) {
+      style &= !WS_OVERLAPPEDWINDOW;
     }
 
-    /// Adjust the window client rectangle to the return value, if present.
-    fn apply_diff(mut self, window: HWND, mut new: WindowFlags) {
-        self = self.mask();
-        new = new.mask();
+    (style, style_ex)
+  }
 
-        let diff = self ^ new;
-        if diff == WindowFlags::empty() {
-            return;
-        }
+  /// Adjust the window client rectangle to the return value, if present.
+  fn apply_diff(mut self, window: HWND, mut new: WindowFlags) {
+    self = self.mask();
+    new = new.mask();
 
-        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::SWP_NOACTIVATE,
-                );
-                winuser::InvalidateRgn(window, ptr::null_mut(), 0);
-            }
-        }
-
-        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,
-                    },
-                );
-            }
-        }
-
-        // Minimize operations should execute after maximize for proper window animations
-        if diff.contains(WindowFlags::MINIMIZED) {
-            unsafe {
-                winuser::ShowWindow(
-                    window,
-                    match new.contains(WindowFlags::MINIMIZED) {
-                        true => winuser::SW_MINIMIZE,
-                        false => winuser::SW_RESTORE,
-                    },
-                );
-            }
-        }
-
-        if diff != WindowFlags::empty() {
-            let (style, style_ex) = new.to_window_styles();
-
-            unsafe {
-                winuser::SendMessageW(window, *event_loop::SET_RETAIN_STATE_ON_SIZE_MSG_ID, 1, 0);
-
-                // This condition is necessary to avoid having an unrestorable window
-                if !new.contains(WindowFlags::MINIMIZED) {
-                    winuser::SetWindowLongW(window, winuser::GWL_STYLE, style as _);
-                    winuser::SetWindowLongW(window, winuser::GWL_EXSTYLE, style_ex as _);
-                }
-
-                let mut flags = winuser::SWP_NOZORDER
-                    | winuser::SWP_NOMOVE
-                    | winuser::SWP_NOSIZE
-                    | winuser::SWP_FRAMECHANGED;
-
-                // We generally don't want style changes here to affect window
-                // focus, but for fullscreen windows they must be activated
-                // (i.e. focused) so that they appear on top of the taskbar
-                if !new.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN)
-                    && !new.contains(WindowFlags::MARKER_BORDERLESS_FULLSCREEN)
-                {
-                    flags |= winuser::SWP_NOACTIVATE;
-                }
-
-                // Refresh the window frame
-                winuser::SetWindowPos(window, ptr::null_mut(), 0, 0, 0, 0, flags);
-                winuser::SendMessageW(window, *event_loop::SET_RETAIN_STATE_ON_SIZE_MSG_ID, 0, 0);
-            }
-        }
+    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::SWP_NOACTIVATE,
+        );
+        winuser::InvalidateRgn(window, ptr::null_mut(), 0);
+      }
+    }
+
+    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,
+          },
+        );
+      }
+    }
+
+    // Minimize operations should execute after maximize for proper window animations
+    if diff.contains(WindowFlags::MINIMIZED) {
+      unsafe {
+        winuser::ShowWindow(
+          window,
+          match new.contains(WindowFlags::MINIMIZED) {
+            true => winuser::SW_MINIMIZE,
+            false => winuser::SW_RESTORE,
+          },
+        );
+      }
+    }
+
+    if diff != WindowFlags::empty() {
+      let (style, style_ex) = new.to_window_styles();
+
+      unsafe {
+        winuser::SendMessageW(window, *event_loop::SET_RETAIN_STATE_ON_SIZE_MSG_ID, 1, 0);
+
+        // This condition is necessary to avoid having an unrestorable window
+        if !new.contains(WindowFlags::MINIMIZED) {
+          winuser::SetWindowLongW(window, winuser::GWL_STYLE, style as _);
+          winuser::SetWindowLongW(window, winuser::GWL_EXSTYLE, style_ex as _);
+        }
+
+        let mut flags = winuser::SWP_NOZORDER
+          | winuser::SWP_NOMOVE
+          | winuser::SWP_NOSIZE
+          | winuser::SWP_FRAMECHANGED;
+
+        // We generally don't want style changes here to affect window
+        // focus, but for fullscreen windows they must be activated
+        // (i.e. focused) so that they appear on top of the taskbar
+        if !new.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN)
+          && !new.contains(WindowFlags::MARKER_BORDERLESS_FULLSCREEN)
+        {
+          flags |= winuser::SWP_NOACTIVATE;
+        }
+
+        // Refresh the window frame
+        winuser::SetWindowPos(window, ptr::null_mut(), 0, 0, 0, 0, flags);
+        winuser::SendMessageW(window, *event_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)?;
+  fn refresh_os_cursor(self, window: HWND) -> Result<(), io::Error> {
+    let client_rect = util::get_client_rect(window)?;
 
-        if util::is_focused(window) {
-            let cursor_clip = match self.contains(CursorFlags::GRABBED) {
-                true => Some(client_rect),
-                false => None,
-            };
+    if util::is_focused(window) {
+      let cursor_clip = match self.contains(CursorFlags::GRABBED) {
+        true => Some(client_rect),
+        false => None,
+      };
 
-            let rect_to_tuple = |rect: RECT| (rect.left, rect.top, rect.right, rect.bottom);
-            let active_cursor_clip = rect_to_tuple(util::get_cursor_clip()?);
-            let desktop_rect = rect_to_tuple(util::get_desktop_rect());
+      let rect_to_tuple = |rect: RECT| (rect.left, rect.top, rect.right, rect.bottom);
+      let active_cursor_clip = rect_to_tuple(util::get_cursor_clip()?);
+      let desktop_rect = rect_to_tuple(util::get_desktop_rect());
 
-            let active_cursor_clip = match desktop_rect == active_cursor_clip {
-                true => None,
-                false => Some(active_cursor_clip),
-            };
+      let active_cursor_clip = match desktop_rect == active_cursor_clip {
+        true => None,
+        false => Some(active_cursor_clip),
+      };
 
-            // We do this check because calling `set_cursor_clip` incessantly will flood the event
-            // loop with `WM_MOUSEMOVE` events, and `refresh_os_cursor` is called by `set_cursor_flags`
-            // which at times gets called once every iteration of the eventloop.
-            if active_cursor_clip != cursor_clip.map(rect_to_tuple) {
-                util::set_cursor_clip(cursor_clip)?;
-            }
-        }
-
-        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(())
+      // We do this check because calling `set_cursor_clip` incessantly will flood the event
+      // loop with `WM_MOUSEMOVE` events, and `refresh_os_cursor` is called by `set_cursor_flags`
+      // which at times gets called once every iteration of the eventloop.
+      if active_cursor_clip != cursor_clip.map(rect_to_tuple) {
+        util::set_cursor_clip(cursor_clip)?;
+      }
     }
+
+    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(())
+  }
 }

tests/send_objects.rs

@@ -1,27 +1,25 @@
 #[allow(dead_code)]
 fn needs_send<T: Send>() {}
 
-#[cfg(not(target_arch = "wasm32"))]
 #[test]
 fn event_loop_proxy_send() {
-    #[allow(dead_code)]
-    fn is_send<T: 'static + Send>() {
-        // ensures that `winit::EventLoopProxy` implements `Send`
-        needs_send::<winit::event_loop::EventLoopProxy<T>>();
-    }
+  #[allow(dead_code)]
+  fn is_send<T: 'static + Send>() {
+    // ensures that `winit::EventLoopProxy` implements `Send`
+    needs_send::<tao::event_loop::EventLoopProxy<T>>();
+  }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 #[test]
 fn window_send() {
-    // ensures that `winit::Window` implements `Send`
-    needs_send::<winit::window::Window>();
+  // ensures that `winit::Window` implements `Send`
+  needs_send::<tao::window::Window>();
 }
 
 #[test]
 fn ids_send() {
-    // ensures that the various `..Id` types implement `Send`
-    needs_send::<winit::window::WindowId>();
-    needs_send::<winit::event::DeviceId>();
-    needs_send::<winit::monitor::MonitorHandle>();
+  // ensures that the various `..Id` types implement `Send`
+  needs_send::<tao::window::WindowId>();
+  needs_send::<tao::event::DeviceId>();
+  needs_send::<tao::monitor::MonitorHandle>();
 }

tests/serde_objects.rs

@@ -1,13 +1,13 @@
 #![cfg(feature = "serde")]
 
 use serde::{Deserialize, Serialize};
-use winit::{
-    dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
-    event::{
-        ElementState, KeyboardInput, ModifiersState, MouseButton, MouseScrollDelta, TouchPhase,
-        VirtualKeyCode,
-    },
-    window::CursorIcon,
+use tao::{
+  dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
+  event::{
+    ElementState, KeyboardInput, ModifiersState, MouseButton, MouseScrollDelta, TouchPhase,
+    VirtualKeyCode,
+  },
+  window::CursorIcon,
 };
 
 #[allow(dead_code)]
@@ -15,25 +15,25 @@ fn needs_serde<S: Serialize + Deserialize<'static>>() {}
 
 #[test]
 fn window_serde() {
-    needs_serde::<CursorIcon>();
+  needs_serde::<CursorIcon>();
 }
 
 #[test]
 fn events_serde() {
-    needs_serde::<KeyboardInput>();
-    needs_serde::<TouchPhase>();
-    needs_serde::<ElementState>();
-    needs_serde::<MouseButton>();
-    needs_serde::<MouseScrollDelta>();
-    needs_serde::<VirtualKeyCode>();
-    needs_serde::<ModifiersState>();
+  needs_serde::<KeyboardInput>();
+  needs_serde::<TouchPhase>();
+  needs_serde::<ElementState>();
+  needs_serde::<MouseButton>();
+  needs_serde::<MouseScrollDelta>();
+  needs_serde::<VirtualKeyCode>();
+  needs_serde::<ModifiersState>();
 }
 
 #[test]
 fn dpi_serde() {
-    needs_serde::<LogicalPosition<f64>>();
-    needs_serde::<PhysicalPosition<i32>>();
-    needs_serde::<PhysicalPosition<f64>>();
-    needs_serde::<LogicalSize<f64>>();
-    needs_serde::<PhysicalSize<u32>>();
+  needs_serde::<LogicalPosition<f64>>();
+  needs_serde::<PhysicalPosition<i32>>();
+  needs_serde::<PhysicalPosition<f64>>();
+  needs_serde::<LogicalSize<f64>>();
+  needs_serde::<PhysicalSize<u32>>();
 }