Add initialization closure and drop on exit

Windows: Add scancode conversions from Chromium sources (#4020 )
AppKit/UIKit: Do not emit default state events upon window creation (#3912 )
2026-06-26 22:53:15 -04:00 · 2024-12-03 13:28:52 +01:00 · 2024-12-03 11:05:22 +01:00 · 2024-12-02 23:10:33 +01:00 · 2024-12-02 13:38:37 +01:00 · 2024-12-02 14:51:26 +03:00
94 changed files with 4218 additions and 3221 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,6 @@ version = "0.30.5"

 [package.metadata.docs.rs]
 features = [
-    "rwh_06",
    "serde",
    "mint",
    # Enabled to get docs to compile
@@ -55,9 +54,8 @@ targets = [
 [features]
 android-game-activity = ["android-activity/game-activity"]
 android-native-activity = ["android-activity/native-activity"]
-default = ["rwh_06", "x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
+default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
 mint = ["dpi/mint"]
-rwh_06 = ["dep:rwh_06", "ndk/rwh_06"]
 serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde", "dpi/serde", "bitflags/serde"]
 wayland = [
    "wayland-client",
@@ -81,7 +79,7 @@ cfg_aliases = "0.2.1"
 bitflags = "2"
 cursor-icon = "1.1.0"
 dpi = { version = "0.1.1", path = "dpi" }
-rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"], optional = true }
+rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"] }
 serde = { workspace = true, optional = true }
 smol_str = "0.2.0"
 tracing = { version = "0.1.40", default-features = false }
@@ -91,8 +89,8 @@ image = { version = "0.25.0", default-features = false, features = ["png"] }
 tracing = { version = "0.1.40", default-features = false, features = ["log"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }

-[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dev-dependencies]
-softbuffer = { version = "0.4.0", default-features = false, features = [
+[target.'cfg(not(target_os = "android"))'.dev-dependencies]
+softbuffer = { version = "0.4.6", default-features = false, features = [
    "x11",
    "x11-dlopen",
    "wayland",
@@ -102,7 +100,7 @@ softbuffer = { version = "0.4.0", default-features = false, features = [
 # Android
 [target.'cfg(target_os = "android")'.dependencies]
 android-activity = "0.6.0"
-ndk = { version = "0.9.0", default-features = false }
+ndk = { version = "0.9.0", features = ["rwh_06"], default-features = false }

 # AppKit or UIKit
 [target.'cfg(target_vendor = "apple")'.dependencies]
@@ -136,6 +134,7 @@ objc2-app-kit = { version = "0.2.2", features = [
    "NSScreen",
    "NSTextInputClient",
    "NSTextInputContext",
+    "NSToolbar",
    "NSView",
    "NSWindow",
    "NSWindowScripting",
@@ -150,6 +149,7 @@ objc2-foundation = { version = "0.2.2", features = [
    "NSDictionary",
    "NSDistributedNotificationCenter",
    "NSEnumerator",
+    "NSGeometry",
    "NSKeyValueObserving",
    "NSNotification",
    "NSObjCRuntime",
@@ -214,6 +214,7 @@ windows-sys = { version = "0.52.0", features = [
    "Win32_System_Com",
    "Win32_System_LibraryLoader",
    "Win32_System_Ole",
+    "Win32_Security",
    "Win32_System_SystemInformation",
    "Win32_System_SystemServices",
    "Win32_System_Threading",
@@ -270,7 +271,7 @@ xkbcommon-dl = "0.4.2"
 # Orbital
 [target.'cfg(target_os = "redox")'.dependencies]
 orbclient = { version = "0.3.47", default-features = false }
-redox_syscall = "0.4.1"
+redox_syscall = "0.5.7"

 # Web
 [target.'cfg(target_family = "wasm")'.dependencies]
@@ -296,6 +297,7 @@ web_sys = { package = "web-sys", version = "0.3.70", features = [
    "FocusEvent",
    "HtmlCanvasElement",
    "HtmlElement",
+    "HtmlHtmlElement",
    "HtmlImageElement",
    "ImageBitmap",
    "ImageBitmapOptions",
@@ -343,11 +345,9 @@ wasm-bindgen-test = "0.3"
 [[example]]
 doc-scrape-examples = true
 name = "window"
-required-features = ["rwh_06"]

 [[example]]
 name = "child_window"
-required-features = ["rwh_06"]

 [workspace]
 members = ["dpi"]
--- a/deny.toml
+++ b/deny.toml
@@ -26,12 +26,12 @@ targets = [

 [licenses]
 allow = [
-    "Apache-2.0",       # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
-    "BSD-2-Clause",     # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
-    "BSD-3-Clause",     # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
-    "ISC",              # https://tldrlegal.com/license/-isc-license
-    "MIT",              # https://tldrlegal.com/license/mit-license
-    "Unicode-DFS-2016", # https://spdx.org/licenses/Unicode-DFS-2016.html
+    "Apache-2.0",   # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause", # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause", # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "ISC",          # https://tldrlegal.com/license/isc-license
+    "MIT",          # https://tldrlegal.com/license/mit-license
+    "Unicode-3.0",  # https://spdx.org/licenses/Unicode-3.0.html
 ]
 confidence-threshold = 1.0
 private = { ignore = true }
--- a/docs/res/ATTRIBUTION.md
+++ b/docs/res/ATTRIBUTION.md
@@ -9,3 +9,10 @@ by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It was
 originally released under the [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)
 License. Minor modifications have been made by [John Nunley](https://github.com/notgull),
 which have been released under the same license as a derivative work.
+
+## `coordinate-systems*`
+
+These files are created by [Mads Marquart](https://github.com/madsmtm) using
+[draw.io](https://draw.io/), and compressed using [svgomg.net](https://svgomg.net/).
+
+They are licensed under the [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.
--- a/docs/coordinate-systems.drawio
+++ b/docs/coordinate-systems.drawio
@@ -0,0 +1,130 @@
+<mxfile host="app.diagrams.net" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0" version="24.8.6" pages="2">
+  <diagram name="desktop" id="3DDum1nDijUk3y7wIDRm">
+    <mxGraphModel dx="1080" dy="707" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1000" pageHeight="500" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-1" value="" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#E8E8E8;fontColor=#333333;strokeColor=#666666;" parent="1" vertex="1">
+          <mxGeometry x="200" y="80" width="480" height="360" as="geometry" />
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-4" value="" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;fillColor=#d5e8d4;strokeColor=#666666;" parent="1" vertex="1">
+          <mxGeometry x="260" y="340" width="360" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-2" value="" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;fillColor=#dae8fc;strokeColor=#666666;" parent="1" vertex="1">
+          <mxGeometry x="260" y="140" width="360" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-3" value="" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#DBDBDB;strokeColor=#666666;fontColor=#333333;" parent="1" vertex="1">
+          <mxGeometry x="200" y="60" width="480" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-5" value="" style="rounded=0;whiteSpace=wrap;html=1;strokeColor=none;fillColor=#d5e8d4;" parent="1" vertex="1">
+          <mxGeometry x="260" y="180" width="360" height="180" as="geometry" />
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-6" value="" style="endArrow=none;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#666666;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-4" target="cRYnzpdCW-J0f_YpP3mc-2" edge="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="10" y="310" as="sourcePoint" />
+            <mxPoint x="60" y="260" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-7" value="" style="endArrow=none;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#666666;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-4" target="cRYnzpdCW-J0f_YpP3mc-2" edge="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="770" y="570" as="sourcePoint" />
+            <mxPoint x="770" y="210" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-8" value="" style="endArrow=none;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0;entryDx=0;entryDy=0;strokeColor=#666666;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-2" target="cRYnzpdCW-J0f_YpP3mc-5" edge="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="220.00000000000023" y="179.69" as="sourcePoint" />
+            <mxPoint x="740.0000000000002" y="179.69" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-9" value="&lt;font&gt;outer_position&lt;/font&gt;" style="endArrow=blockThin;html=1;strokeWidth=3;rounded=0;exitX=0;exitY=0;exitDx=0;exitDy=0;dashed=1;align=right;fontSize=20;fontFamily=monospace;fontColor=#6C8EBF;labelBackgroundColor=none;spacingLeft=0;spacingRight=15;spacing=0;fillColor=#dae8fc;strokeColor=#6C8EBF;endFill=1;startArrow=oval;startFill=1;endSize=6;targetPerimeterSpacing=0;entryX=0;entryY=0;entryDx=0;entryDy=0;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-3" edge="1" target="cRYnzpdCW-J0f_YpP3mc-2">
+          <mxGeometry x="-0.36" y="-24" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="80" y="160" as="sourcePoint" />
+            <mxPoint x="240" y="160" as="targetPoint" />
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-10" value="&lt;font&gt;outer_size&lt;/font&gt;" style="endArrow=none;html=1;strokeWidth=3;rounded=0;dashed=1;align=left;fontSize=20;fontFamily=monospace;fontColor=#6C8EBF;labelBackgroundColor=none;spacingLeft=15;spacingRight=0;spacing=0;exitX=1;exitY=0;exitDx=0;exitDy=0;fillColor=#dae8fc;strokeColor=#6c8ebf;entryX=1;entryY=1;entryDx=0;entryDy=0;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-2" edge="1" target="cRYnzpdCW-J0f_YpP3mc-4">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="850" y="170" as="sourcePoint" />
+            <mxPoint x="760" y="420" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="860" y="140" />
+              <mxPoint x="860" y="380" />
+            </Array>
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-11" value="&lt;font&gt;surface_size&lt;/font&gt;" style="endArrow=none;html=1;strokeWidth=3;rounded=0;dashed=1;align=left;fontSize=20;fontFamily=monospace;fontColor=#82B366;labelBackgroundColor=none;spacingLeft=15;spacingRight=0;spacing=0;entryX=1;entryY=1;entryDx=0;entryDy=0;fillColor=#d5e8d4;strokeColor=#82B366;" parent="1" target="cRYnzpdCW-J0f_YpP3mc-4" edge="1">
+          <mxGeometry x="0.0526" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="600" y="180" as="sourcePoint" />
+            <mxPoint x="760" y="420" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="700" y="180" />
+              <mxPoint x="700" y="380" />
+            </Array>
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="cRYnzpdCW-J0f_YpP3mc-12" value="&lt;font&gt;surface_position&lt;/font&gt;" style="endArrow=blockThin;html=1;strokeWidth=3;rounded=0;dashed=1;align=right;fontSize=20;fontFamily=monospace;fontColor=#82B366;labelBackgroundColor=none;spacingLeft=0;spacingRight=15;spacing=0;fillColor=#d5e8d4;strokeColor=#82b366;exitX=0;exitY=0;exitDx=0;exitDy=0;entryX=0;entryY=0;entryDx=0;entryDy=0;curved=1;startArrow=oval;startFill=1;endFill=1;" parent="1" source="cRYnzpdCW-J0f_YpP3mc-2" target="cRYnzpdCW-J0f_YpP3mc-5" edge="1">
+          <mxGeometry y="-50" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="140" y="140" as="sourcePoint" />
+            <mxPoint x="160" y="200" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="250" y="160" />
+            </Array>
+            <mxPoint x="-5" y="-22" as="offset" />
+          </mxGeometry>
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+  <diagram name="mobile" id="D5mAeJSS4Z33KEKjPCBt">
+    <mxGraphModel dx="1710" dy="1120" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="720" pageHeight="720" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-1" value="" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#E8E8E8;fontColor=#333333;strokeColor=#666666;" parent="1" vertex="1">
+          <mxGeometry x="200" y="40" width="320" height="640" as="geometry" />
+        </mxCell>
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-2" value="" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;fillColor=#d5e8d4;strokeColor=#82b366;" parent="1" vertex="1">
+          <mxGeometry x="210" y="50" width="300" height="620" as="geometry" />
+        </mxCell>
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-4" value="" style="rounded=0;whiteSpace=wrap;html=1;shadow=0;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" vertex="1">
+          <mxGeometry x="210" y="90" width="300" height="540" as="geometry" />
+        </mxCell>
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-20" value="" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#DBDBDB;strokeColor=#666666;fontColor=#333333;" parent="1" vertex="1">
+          <mxGeometry x="290" y="640" width="140" height="10" as="geometry" />
+        </mxCell>
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-3" value="" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#DBDBDB;strokeColor=#666666;fontColor=#333333;" parent="1" vertex="1">
+          <mxGeometry x="300" y="50" width="120" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="RxwCrVmIsQwV7z5iJ9nY-12" value="&lt;font&gt;surface_size&lt;/font&gt;" style="endArrow=none;html=1;strokeWidth=3;rounded=0;dashed=1;align=left;fontSize=20;fontFamily=monospace;fontColor=#82B366;labelBackgroundColor=none;spacingLeft=15;spacingRight=15;spacing=0;fillColor=#d5e8d4;strokeColor=#82b366;exitX=1;exitY=0;exitDx=0;exitDy=0;" parent="1" source="RxwCrVmIsQwV7z5iJ9nY-2" edge="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="210" y="50" as="sourcePoint" />
+            <mxPoint x="510" y="670" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="560" y="50" />
+              <mxPoint x="560" y="670" />
+            </Array>
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="NrHAzeOh65jb3hkBOxW9-1" value="&lt;div&gt;safe_area.top&lt;/div&gt;" style="endArrow=blockThin;html=1;strokeWidth=3;rounded=0;align=right;fontSize=20;fontFamily=monospace;fontColor=#D79B00;labelBackgroundColor=none;spacingLeft=0;spacingRight=15;spacing=0;fillColor=#ffe6cc;strokeColor=#d79b00;startArrow=blockThin;startFill=1;endFill=1;" edge="1" parent="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="180" y="50" as="sourcePoint" />
+            <mxPoint x="180" y="90" as="targetPoint" />
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="NrHAzeOh65jb3hkBOxW9-5" value="&lt;div&gt;safe_area.bottom&lt;/div&gt;" style="endArrow=blockThin;html=1;strokeWidth=3;rounded=0;align=right;fontSize=20;fontFamily=monospace;fontColor=#D79B00;labelBackgroundColor=none;spacingLeft=0;spacingRight=15;spacing=0;fillColor=#ffe6cc;strokeColor=#d79b00;startArrow=blockThin;startFill=1;endFill=1;" edge="1" parent="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="180" y="670" as="sourcePoint" />
+            <mxPoint x="180" y="630" as="targetPoint" />
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>
--- a/docs/res/coordinate-systems-desktop.svg
+++ b/docs/res/coordinate-systems-desktop.svg
--- a/docs/res/coordinate-systems-mobile.svg
+++ b/docs/res/coordinate-systems-mobile.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="720" height="720" viewBox="-0.5 -0.5 720 720" class="ge-export-svg-auto"><defs><style><![CDATA[@media (prefers-color-scheme:dark){svg.ge-export-svg-auto svg:not(mjx-container>svg),svg.ge-export-svg-auto:not(mjx-container>svg){filter:invert(100%) hue-rotate(180deg)}}]]></style></defs><g data-cell-id="0"><g data-cell-id="1"><rect x="200" y="40" width="320" height="640" rx="48" ry="48" fill="#e8e8e8" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-1"/><rect x="210" y="50" width="300" height="620" rx="45" ry="45" fill="#d5e8d4" stroke="#82b366" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-2"/><path fill="#ffe6cc" stroke="#d79b00" pointer-events="all" d="M210 90h300v540H210z" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-4"/><rect x="290" y="640" width="140" height="10" rx="1.5" ry="1.5" fill="#dbdbdb" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-20"/><rect x="300" y="50" width="120" height="30" rx="4.5" ry="4.5" fill="#dbdbdb" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-3"/><g data-cell-id="RxwCrVmIsQwV7z5iJ9nY-12"><path d="M510 50h50v620h-50" fill="none" stroke="#82b366" stroke-width="3" stroke-miterlimit="10" stroke-dasharray="9 9" pointer-events="stroke"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:360px;margin-left:575px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: #82B366;"><div style="display:inline-block;font-size:20px;font-family:&quot;monospace&quot;;color:#82b366;line-height:1.2;pointer-events:all;white-space:nowrap"><font>surface_size</font></div></div></div></foreignObject><text x="575" y="366" fill="#82B366" font-family="&quot;monospace&quot;" font-size="20">surfa...</text></switch></g><g data-cell-id="NrHAzeOh65jb3hkBOxW9-1"><path d="M180 62.35v15.3" fill="none" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="stroke"/><path d="m180 53.35 3 9h-6ZM180 86.65l-3-9h6Z" fill="#d79b00" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-end;width:1px;height:1px;padding-top:70px;margin-left:165px"><div style="box-sizing:border-box;font-size:0;text-align:right" data-drawio-colors="color: #D79B00;"><div style="display:inline-block;font-size:20px;font-family:&quot;monospace&quot;;color:#d79b00;line-height:1.2;pointer-events:all;white-space:nowrap"><div>safe_area.top</div></div></div></div></foreignObject><text x="165" y="76" fill="#D79B00" font-family="&quot;monospace&quot;" font-size="20" text-anchor="end">safe_...</text></switch></g><g data-cell-id="NrHAzeOh65jb3hkBOxW9-5"><path d="M180 657.65v-15.3" fill="none" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="stroke"/><path d="m180 666.65-3-9h6ZM180 633.35l3 9h-6Z" fill="#d79b00" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-end;width:1px;height:1px;padding-top:650px;margin-left:165px"><div style="box-sizing:border-box;font-size:0;text-align:right" data-drawio-colors="color: #D79B00;"><div style="display:inline-block;font-size:20px;font-family:&quot;monospace&quot;;color:#d79b00;line-height:1.2;pointer-events:all;white-space:nowrap"><div>safe_area.bottom</div></div></div></div></foreignObject><text x="165" y="656" fill="#D79B00" font-family="&quot;monospace&quot;" font-size="20" text-anchor="end">safe_...</text></switch></g></g></g></svg>
--- a/dpi/CHANGELOG.md
+++ b/dpi/CHANGELOG.md
@@ -11,6 +11,8 @@ Unreleased` header.

 ## Unreleased

+- Added `Insets`, `LogicalInsets` and `PhysicalInsets` types.
+
 ## 0.1.1

 - Derive `Debug`, `Copy`, `Clone`, `PartialEq`, `Serialize`, `Deserialize` traits for `PixelUnit`.
--- a/dpi/src/lib.rs
+++ b/dpi/src/lib.rs
@@ -759,6 +759,150 @@ impl<P: Pixel> From<LogicalPosition<P>> for Position {
    }
 }

+/// The logical distance between the edges of two rectangles.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct LogicalInsets<P> {
+    /// The distance to the top edge.
+    pub top: P,
+    /// The distance to the left edge.
+    pub left: P,
+    /// The distance to the bottom edge.
+    pub bottom: P,
+    /// The distance to the right edge.
+    pub right: P,
+}
+
+impl<P> LogicalInsets<P> {
+    #[inline]
+    pub const fn new(top: P, left: P, bottom: P, right: P) -> Self {
+        Self { top, left, bottom, right }
+    }
+}
+
+impl<P: Pixel> LogicalInsets<P> {
+    #[inline]
+    pub fn from_physical<T: Into<PhysicalInsets<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) -> PhysicalInsets<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let top = self.top.into() * scale_factor;
+        let left = self.left.into() * scale_factor;
+        let bottom = self.bottom.into() * scale_factor;
+        let right = self.right.into() * scale_factor;
+        PhysicalInsets::new(top, left, bottom, right).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> LogicalInsets<X> {
+        LogicalInsets {
+            top: self.top.cast(),
+            left: self.left.cast(),
+            bottom: self.bottom.cast(),
+            right: self.right.cast(),
+        }
+    }
+}
+
+/// The physical distance between the edges of two rectangles.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct PhysicalInsets<P> {
+    /// The distance to the top edge.
+    pub top: P,
+    /// The distance to the left edge.
+    pub left: P,
+    /// The distance to the bottom edge.
+    pub bottom: P,
+    /// The distance to the right edge.
+    pub right: P,
+}
+
+impl<P> PhysicalInsets<P> {
+    #[inline]
+    pub const fn new(top: P, left: P, bottom: P, right: P) -> Self {
+        Self { top, left, bottom, right }
+    }
+}
+
+impl<P: Pixel> PhysicalInsets<P> {
+    #[inline]
+    pub fn from_logical<T: Into<LogicalInsets<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) -> LogicalInsets<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let top = self.top.into() / scale_factor;
+        let left = self.left.into() / scale_factor;
+        let bottom = self.bottom.into() / scale_factor;
+        let right = self.right.into() / scale_factor;
+        LogicalInsets::new(top, left, bottom, right).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> PhysicalInsets<X> {
+        PhysicalInsets {
+            top: self.top.cast(),
+            left: self.left.cast(),
+            bottom: self.bottom.cast(),
+            right: self.right.cast(),
+        }
+    }
+}
+
+/// Insets that are either physical or logical.
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Insets {
+    Physical(PhysicalInsets<u32>),
+    Logical(LogicalInsets<f64>),
+}
+
+impl Insets {
+    pub fn new<S: Into<Self>>(insets: S) -> Self {
+        insets.into()
+    }
+
+    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalInsets<P> {
+        match *self {
+            Self::Physical(insets) => insets.to_logical(scale_factor),
+            Self::Logical(insets) => insets.cast(),
+        }
+    }
+
+    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalInsets<P> {
+        match *self {
+            Self::Physical(insets) => insets.cast(),
+            Self::Logical(insets) => insets.to_physical(scale_factor),
+        }
+    }
+}
+
+impl<P: Pixel> From<PhysicalInsets<P>> for Insets {
+    #[inline]
+    fn from(insets: PhysicalInsets<P>) -> Self {
+        Self::Physical(insets.cast())
+    }
+}
+
+impl<P: Pixel> From<LogicalInsets<P>> for Insets {
+    #[inline]
+    fn from(insets: LogicalInsets<P>) -> Self {
+        Self::Logical(insets.cast())
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use std::collections::HashSet;
--- a/examples/child_window.rs
+++ b/examples/child_window.rs
@@ -13,26 +13,12 @@ fn main() -> Result<(), impl std::error::Error> {
    #[path = "util/fill.rs"]
    mod fill;

-    #[derive(Default)]
    struct Application {
-        parent_window_id: Option<WindowId>,
+        parent_window_id: WindowId,
        windows: HashMap<WindowId, Box<dyn Window>>,
    }

    impl ApplicationHandler for Application {
-        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let attributes = WindowAttributes::default()
-                .with_title("parent window")
-                .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
-                .with_surface_size(LogicalSize::new(640.0f32, 480.0f32));
-            let window = event_loop.create_window(attributes).unwrap();
-
-            println!("Parent window id: {:?})", window.id());
-            self.parent_window_id = Some(window.id());
-
-            self.windows.insert(window.id(), window);
-        }
-
        fn window_event(
            &mut self,
            event_loop: &dyn ActiveEventLoop,
@@ -44,7 +30,7 @@ fn main() -> Result<(), impl std::error::Error> {
                    self.windows.clear();
                    event_loop.exit();
                },
-                WindowEvent::CursorEntered { device_id: _ } => {
+                WindowEvent::PointerEntered { device_id: _, .. } => {
                    // On x11, println when the cursor entered in a window even if the child window
                    // is created by some key inputs.
                    // the child windows are always placed at (0, 0) with size (200, 200) in the
@@ -56,7 +42,7 @@ fn main() -> Result<(), impl std::error::Error> {
                    event: KeyEvent { state: ElementState::Pressed, .. },
                    ..
                } => {
-                    let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
+                    let parent_window = self.windows.get(&self.parent_window_id).unwrap();
                    let child_window = spawn_child_window(parent_window.as_ref(), event_loop);
                    let child_id = child_window.id();
                    println!("Child window created with id: {child_id:?}");
@@ -72,6 +58,20 @@ fn main() -> Result<(), impl std::error::Error> {
        }
    }

+    fn init(event_loop: &dyn ActiveEventLoop) -> Application {
+        let attributes = WindowAttributes::default()
+            .with_title("parent window")
+            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+            .with_surface_size(LogicalSize::new(640.0f32, 480.0f32));
+        let window = event_loop.create_window(attributes).unwrap();
+
+        println!("Parent window id: {:?})", window.id());
+
+        let parent_window_id = window.id();
+        let windows = HashMap::from([(window.id(), window)]);
+        Application { parent_window_id, windows }
+    }
+
    fn spawn_child_window(
        parent: &dyn Window,
        event_loop: &dyn ActiveEventLoop,
@@ -89,7 +89,7 @@ fn main() -> Result<(), impl std::error::Error> {
    }

    let event_loop = EventLoop::new().unwrap();
-    event_loop.run_app(Application::default())
+    event_loop.run(init)
 }

 #[cfg(not(any(x11_platform, macos_platform, windows_platform)))]
--- a/examples/control_flow.rs
+++ b/examples/control_flow.rs
@@ -43,16 +43,31 @@ fn main() -> Result<(), impl std::error::Error> {

    let event_loop = EventLoop::new().unwrap();

-    event_loop.run_app(ControlFlowDemo::default())
+    event_loop.run(ControlFlowDemo::new)
 }

-#[derive(Default)]
 struct ControlFlowDemo {
    mode: Mode,
    request_redraw: bool,
    wait_cancelled: bool,
    close_requested: bool,
-    window: Option<Box<dyn Window>>,
+    window: Box<dyn Window>,
+}
+
+impl ControlFlowDemo {
+    fn new(event_loop: &dyn ActiveEventLoop) -> Self {
+        let window_attributes = WindowAttributes::default().with_title(
+            "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
+        );
+        let window = event_loop.create_window(window_attributes).unwrap();
+        Self {
+            mode: Mode::default(),
+            request_redraw: false,
+            wait_cancelled: false,
+            close_requested: false,
+            window,
+        }
+    }
 }

 impl ApplicationHandler for ControlFlowDemo {
@@ -65,13 +80,6 @@ impl ApplicationHandler for ControlFlowDemo {
        }
    }

-    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-        let window_attributes = WindowAttributes::default().with_title(
-            "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
-        );
-        self.window = Some(event_loop.create_window(window_attributes).unwrap());
-    }
-
    fn window_event(
        &mut self,
        _event_loop: &dyn ActiveEventLoop,
@@ -112,9 +120,8 @@ impl ApplicationHandler for ControlFlowDemo {
                _ => (),
            },
            WindowEvent::RedrawRequested => {
-                let window = self.window.as_ref().unwrap();
-                window.pre_present_notify();
-                fill::fill_window(window.as_ref());
+                self.window.pre_present_notify();
+                fill::fill_window(&*self.window);
            },
            _ => (),
        }
@@ -122,7 +129,7 @@ impl ApplicationHandler for ControlFlowDemo {

    fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
        if self.request_redraw && !self.wait_cancelled && !self.close_requested {
-            self.window.as_ref().unwrap().request_redraw();
+            self.window.request_redraw();
        }

        match self.mode {
--- a/examples/pump_events.rs
+++ b/examples/pump_events.rs
@@ -8,7 +8,7 @@ fn main() -> std::process::ExitCode {
    use std::time::Duration;

    use winit::application::ApplicationHandler;
-    use winit::event::WindowEvent;
+    use winit::event::{StartCause, WindowEvent};
    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::platform::pump_events::{EventLoopExtPumpEvents, PumpStatus};
    use winit::window::{Window, WindowAttributes, WindowId};
@@ -22,9 +22,12 @@ fn main() -> std::process::ExitCode {
    }

    impl ApplicationHandler for PumpDemo {
-        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let window_attributes = WindowAttributes::default().with_title("A fantastic window!");
-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        fn new_events(&mut self, event_loop: &dyn ActiveEventLoop, cause: StartCause) {
+            if matches!(cause, StartCause::Init) && self.window.is_none() {
+                let window_attributes =
+                    WindowAttributes::default().with_title("A fantastic window!");
+                self.window = Some(event_loop.create_window(window_attributes).unwrap());
+            }
        }

        fn window_event(
--- a/examples/run_on_demand.rs
+++ b/examples/run_on_demand.rs
@@ -21,14 +21,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        window: Option<Box<dyn Window>>,
    }

-    impl ApplicationHandler for App {
-        fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            if let Some(window) = self.window.as_ref() {
-                window.request_redraw();
-            }
-        }
-
-        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+    impl App {
+        fn init_window(&mut self, event_loop: &dyn ActiveEventLoop) {
            let window_attributes = WindowAttributes::default()
                .with_title("Fantastic window number one!")
                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0));
@@ -36,6 +30,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
            self.window_id = Some(window.id());
            self.window = Some(window);
        }
+    }
+
+    impl ApplicationHandler for App {
+        fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
+            if let Some(window) = self.window.as_ref() {
+                window.request_redraw();
+            }
+        }

        fn window_event(
            &mut self,
@@ -81,14 +83,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut event_loop = EventLoop::new().unwrap();

    let mut app = App { idx: 1, ..Default::default() };
-    event_loop.run_app_on_demand(&mut app)?;
+    event_loop.run_on_demand(|event_loop| {
+        app.init_window(event_loop);
+        &mut app
+    })?;

    println!("--------------------------------------------------------- Finished first loop");
    println!("--------------------------------------------------------- Waiting 5 seconds");
    std::thread::sleep(Duration::from_secs(5));

    app.idx += 1;
-    event_loop.run_app_on_demand(&mut app)?;
+    event_loop.run_on_demand(|event_loop| {
+        app.init_window(event_loop);
+        &mut app
+    })?;
    println!("--------------------------------------------------------- Finished second loop");
    Ok(())
 }
--- a/examples/util/fill.rs
+++ b/examples/util/fill.rs
@@ -11,7 +11,7 @@
 pub use platform::cleanup_window;
 pub use platform::fill_window;

-#[cfg(all(feature = "rwh_06", not(any(target_os = "android", target_os = "ios"))))]
+#[cfg(not(any(target_os = "android", target_os = "ios")))]
 mod platform {
    use std::cell::RefCell;
    use std::collections::HashMap;
@@ -106,7 +106,7 @@ mod platform {
    }
 }

-#[cfg(not(all(feature = "rwh_06", not(any(target_os = "android", target_os = "ios")))))]
+#[cfg(any(target_os = "android", target_os = "ios"))]
 mod platform {
    pub fn fill_window(_window: &dyn winit::window::Window) {
        // No-op on mobile platforms.
--- a/examples/window.rs
+++ b/examples/window.rs
@@ -3,7 +3,7 @@
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Debug;
-#[cfg(not(any(android_platform, ios_platform)))]
+#[cfg(not(android_platform))]
 use std::num::NonZeroU32;
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::Arc;
@@ -11,9 +11,9 @@ use std::{fmt, mem};

 use ::tracing::{error, info};
 use cursor_icon::CursorIcon;
-#[cfg(not(any(android_platform, ios_platform)))]
+#[cfg(not(android_platform))]
 use rwh_06::{DisplayHandle, HasDisplayHandle};
-#[cfg(not(any(android_platform, ios_platform)))]
+#[cfg(not(android_platform))]
 use softbuffer::{Context, Surface};
 use winit::application::ApplicationHandler;
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
@@ -22,13 +22,17 @@ use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, Wi
 use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::keyboard::{Key, ModifiersState};
 #[cfg(macos_platform)]
-use winit::platform::macos::{OptionAsAlt, WindowAttributesExtMacOS, WindowExtMacOS};
+use winit::platform::macos::{
+    ApplicationHandlerExtMacOS, OptionAsAlt, WindowAttributesExtMacOS, WindowExtMacOS,
+};
 #[cfg(any(x11_platform, wayland_platform))]
 use winit::platform::startup_notify::{
    self, EventLoopExtStartupNotify, WindowAttributesExtStartupNotify, WindowExtStartupNotify,
 };
 #[cfg(web_platform)]
 use winit::platform::web::{ActiveEventLoopExtWeb, CustomCursorExtWeb, WindowAttributesExtWeb};
+#[cfg(x11_platform)]
+use winit::platform::x11::WindowAttributesExtX11;
 use winit::window::{
    Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, Icon, ResizeDirection,
    Theme, Window, WindowAttributes, WindowId,
@@ -66,8 +70,7 @@ fn main() -> Result<(), Box<dyn Error>> {
        });
    }

-    let app = Application::new(&event_loop, receiver, sender);
-    Ok(event_loop.run_app(app)?)
+    Ok(event_loop.run(|event_loop| Application::new(event_loop, receiver, sender))?)
 }

 /// Application state and event handling.
@@ -83,22 +86,25 @@ struct Application {
    /// Drawing context.
    ///
    /// With OpenGL it could be EGLDisplay.
-    #[cfg(not(any(android_platform, ios_platform)))]
-    context: Option<Context<DisplayHandle<'static>>>,
+    #[cfg(not(android_platform))]
+    context: Context<DisplayHandle<'static>>,
 }

 impl Application {
-    fn new(event_loop: &EventLoop, receiver: Receiver<Action>, sender: Sender<Action>) -> Self {
-        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
-        #[cfg(not(any(android_platform, ios_platform)))]
-        let context = Some(
-            Context::new(unsafe {
-                std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
-                    event_loop.display_handle().unwrap(),
-                )
-            })
-            .unwrap(),
-        );
+    fn new(
+        event_loop: &dyn ActiveEventLoop,
+        receiver: Receiver<Action>,
+        sender: Sender<Action>,
+    ) -> Self {
+        // SAFETY: The context is stored in the application, which is dropped right before the event
+        // loop is stopped, thus making it safe.
+        #[cfg(not(android_platform))]
+        let context = Context::new(unsafe {
+            std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
+                event_loop.display_handle().unwrap(),
+            )
+        })
+        .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
@@ -116,15 +122,24 @@ impl Application {
        .into_iter()
        .collect();

-        Self {
+        let mut app = Self {
            receiver,
            sender,
-            #[cfg(not(any(android_platform, ios_platform)))]
+            #[cfg(not(android_platform))]
            context,
            custom_cursors,
            icon,
            windows: Default::default(),
-        }
+        };
+
+        app.dump_monitors(event_loop);
+
+        // Create initial window.
+        app.create_window(event_loop, None).expect("failed to create initial window");
+
+        app.print_help();
+
+        app
    }

    fn create_window(
@@ -147,6 +162,28 @@ impl Application {
            window_attributes = window_attributes.with_activation_token(token);
        }

+        #[cfg(x11_platform)]
+        match std::env::var("X11_VISUAL_ID") {
+            Ok(visual_id_str) => {
+                info!("Using X11 visual id {visual_id_str}");
+                let visual_id = visual_id_str.parse()?;
+                window_attributes = window_attributes.with_x11_visual(visual_id);
+            },
+            Err(_) => info!("Set the X11_VISUAL_ID env variable to request specific X11 visual"),
+        }
+
+        #[cfg(x11_platform)]
+        match std::env::var("X11_SCREEN_ID") {
+            Ok(screen_id_str) => {
+                info!("Placing the window on X11 screen {screen_id_str}");
+                let screen_id = screen_id_str.parse()?;
+                window_attributes = window_attributes.with_x11_screen(screen_id);
+            },
+            Err(_) => info!(
+                "Set the X11_SCREEN_ID env variable to place the window on non-default screen"
+            ),
+        }
+
        #[cfg(macos_platform)]
        if let Some(tab_id) = _tab_id {
            window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
@@ -216,6 +253,10 @@ impl Application {
            Action::ToggleResizable => window.toggle_resizable(),
            Action::ToggleDecorations => window.toggle_decorations(),
            Action::ToggleFullscreen => window.toggle_fullscreen(),
+            #[cfg(macos_platform)]
+            Action::ToggleSimpleFullscreen => {
+                window.window.set_simple_fullscreen(!window.window.simple_fullscreen());
+            },
            Action::ToggleMaximize => window.toggle_maximize(),
            Action::ToggleImeInput => window.toggle_ime(),
            Action::Minimize => window.minimize(),
@@ -446,20 +487,23 @@ impl ApplicationHandler for Application {
                    }
                }
            },
-            WindowEvent::MouseInput { button, state, .. } => {
+            WindowEvent::PointerButton { button, state, .. } => {
+                info!("Pointer button {button:?} {state:?}");
                let mods = window.modifiers;
-                if let Some(action) =
-                    state.is_pressed().then(|| Self::process_mouse_binding(button, &mods)).flatten()
+                if let Some(action) = state
+                    .is_pressed()
+                    .then(|| Self::process_mouse_binding(button.mouse_button(), &mods))
+                    .flatten()
                {
                    self.handle_action_with_window(event_loop, window_id, action);
                }
            },
-            WindowEvent::CursorLeft { .. } => {
-                info!("Cursor left Window={window_id:?}");
+            WindowEvent::PointerLeft { .. } => {
+                info!("Pointer left Window={window_id:?}");
                window.cursor_left();
            },
-            WindowEvent::CursorMoved { position, .. } => {
-                info!("Moved cursor to {position:?}");
+            WindowEvent::PointerMoved { position, .. } => {
+                info!("Moved pointer to {position:?}");
                window.cursor_moved(position);
            },
            WindowEvent::ActivationTokenDone { token: _token, .. } => {
@@ -510,11 +554,10 @@ impl ApplicationHandler for Application {
            WindowEvent::TouchpadPressure { .. }
            | WindowEvent::HoveredFileCancelled
            | WindowEvent::KeyboardInput { .. }
-            | WindowEvent::CursorEntered { .. }
+            | WindowEvent::PointerEntered { .. }
            | WindowEvent::DroppedFile(_)
            | WindowEvent::HoveredFile(_)
            | WindowEvent::Destroyed
-            | WindowEvent::Touch(_)
            | WindowEvent::Moved(_) => (),
        }
    }
@@ -522,20 +565,18 @@ impl ApplicationHandler for Application {
    fn device_event(
        &mut self,
        _event_loop: &dyn ActiveEventLoop,
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        event: DeviceEvent,
    ) {
        info!("Device {device_id:?} event: {event:?}");
    }

-    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-        info!("Ready to create surfaces");
-        self.dump_monitors(event_loop);
-
-        // Create initial window.
-        self.create_window(event_loop, None).expect("failed to create initial window");
-
-        self.print_help();
+    #[cfg(not(android_platform))]
+    fn can_create_surfaces(&mut self, _event_loop: &dyn ActiveEventLoop) {
+        for window in self.windows.values_mut() {
+            window.surface = Some(Surface::new(&self.context, Arc::clone(&window.window)).unwrap());
+            window.resize(window.window.surface_size());
+        }
    }

    fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
@@ -545,10 +586,28 @@ impl ApplicationHandler for Application {
        }
    }

-    #[cfg(not(any(android_platform, ios_platform)))]
-    fn exiting(&mut self, _event_loop: &dyn ActiveEventLoop) {
-        // We must drop the context here.
-        self.context = None;
+    #[cfg(not(android_platform))]
+    fn destroy_surfaces(&mut self, _event_loop: &dyn ActiveEventLoop) {
+        for window in self.windows.values_mut() {
+            window.surface = None;
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+        Some(self)
+    }
+}
+
+#[cfg(target_os = "macos")]
+impl ApplicationHandlerExtMacOS for Application {
+    fn standard_key_binding(
+        &mut self,
+        _event_loop: &dyn ActiveEventLoop,
+        window_id: WindowId,
+        action: &str,
+    ) {
+        info!(?window_id, ?action, "macOS standard key binding");
    }
 }

@@ -558,9 +617,9 @@ struct WindowState {
    ime: bool,
    /// Render surface.
    ///
-    /// NOTE: This surface must be dropped before the `Window`.
-    #[cfg(not(any(android_platform, ios_platform)))]
-    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
+    /// `None` when not between `can_create_surfaces` and `destroy_surfaces`.
+    #[cfg(not(android_platform))]
+    surface: Option<Surface<DisplayHandle<'static>, Arc<dyn Window>>>,
    /// The actual winit Window.
    window: Arc<dyn Window>,
    /// The window theme we're drawing with.
@@ -593,11 +652,6 @@ impl WindowState {
    fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
        let window: Arc<dyn Window> = Arc::from(window);

-        // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
-        // it doesn't outlive it.
-        #[cfg(not(any(android_platform, ios_platform)))]
-        let surface = Surface::new(app.context.as_ref().unwrap(), Arc::clone(&window))?;
-
        let theme = window.theme().unwrap_or(Theme::Dark);
        info!("Theme: {theme:?}");
        let named_idx = 0;
@@ -607,15 +661,14 @@ impl WindowState {
        let ime = true;
        window.set_ime_allowed(ime);

-        let size = window.surface_size();
-        let mut state = Self {
+        Ok(Self {
            #[cfg(macos_platform)]
            option_as_alt: window.option_as_alt(),
            custom_idx: app.custom_cursors.as_ref().map(Vec::len).unwrap_or(1) - 1,
            cursor_grab: CursorGrabMode::None,
            named_idx,
-            #[cfg(not(any(android_platform, ios_platform)))]
-            surface,
+            #[cfg(not(android_platform))]
+            surface: None,
            window,
            theme,
            ime,
@@ -626,10 +679,7 @@ impl WindowState {
            rotated: Default::default(),
            panned: Default::default(),
            zoom: Default::default(),
-        };
-
-        state.resize(size);
-        Ok(state)
+        })
    }

    pub fn toggle_ime(&mut self) {
@@ -796,14 +846,18 @@ impl WindowState {
    /// Resize the surface to the new size.
    fn resize(&mut self, size: PhysicalSize<u32>) {
        info!("Surface resized to {size:?}");
-        #[cfg(not(any(android_platform, ios_platform)))]
+        #[cfg(not(android_platform))]
        {
            let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
            {
                (Some(width), Some(height)) => (width, height),
                _ => return,
            };
-            self.surface.resize(width, height).expect("failed to resize inner buffer");
+            self.surface
+                .as_mut()
+                .unwrap()
+                .resize(width, height)
+                .expect("failed to resize inner buffer");
        }
        self.window.request_redraw();
    }
@@ -889,29 +943,49 @@ impl WindowState {
    }

    /// Draw the window contents.
-    #[cfg(not(any(android_platform, ios_platform)))]
+    #[cfg(not(android_platform))]
    fn draw(&mut self) -> Result<(), Box<dyn Error>> {
        if self.occluded {
            info!("Skipping drawing occluded window={:?}", self.window.id());
            return Ok(());
        }

-        const WHITE: u32 = 0xffffffff;
-        const DARK_GRAY: u32 = 0xff181818;
+        let mut buffer = self.surface.as_mut().unwrap().buffer_mut()?;

-        let color = match self.theme {
-            Theme::Light => WHITE,
-            Theme::Dark => DARK_GRAY,
-        };
+        // Draw a different color inside the safe area
+        let surface_size = self.window.surface_size();
+        let insets = self.window.safe_area();
+        for y in 0..surface_size.height {
+            for x in 0..surface_size.width {
+                let index = y as usize * surface_size.width as usize + x as usize;
+                if insets.left <= x
+                    && x <= (surface_size.width - insets.right)
+                    && insets.top <= y
+                    && y <= (surface_size.height - insets.bottom)
+                {
+                    // In safe area
+                    buffer[index] = match self.theme {
+                        Theme::Light => 0xffe8e8e8, // Light gray
+                        Theme::Dark => 0xff525252,  // Medium gray
+                    };
+                } else {
+                    // Outside safe area
+                    buffer[index] = match self.theme {
+                        Theme::Light => 0xffffffff, // White
+                        Theme::Dark => 0xff181818,  // Dark gray
+                    };
+                }
+            }
+        }

-        let mut buffer = self.surface.buffer_mut()?;
-        buffer.fill(color);
+        // Present the buffer
        self.window.pre_present_notify();
        buffer.present()?;
+
        Ok(())
    }

-    #[cfg(any(android_platform, ios_platform))]
+    #[cfg(android_platform)]
    fn draw(&mut self) -> Result<(), Box<dyn Error>> {
        info!("Drawing but without rendering...");
        Ok(())
@@ -944,6 +1018,8 @@ enum Action {
    ToggleDecorations,
    ToggleResizable,
    ToggleFullscreen,
+    #[cfg(macos_platform)]
+    ToggleSimpleFullscreen,
    ToggleMaximize,
    Minimize,
    NextCursor,
@@ -977,6 +1053,8 @@ impl Action {
            Action::ToggleDecorations => "Toggle decorations",
            Action::ToggleResizable => "Toggle window resizable state",
            Action::ToggleFullscreen => "Toggle fullscreen",
+            #[cfg(macos_platform)]
+            Action::ToggleSimpleFullscreen => "Toggle simple fullscreen",
            Action::ToggleMaximize => "Maximize",
            Action::Minimize => "Minimize",
            Action::ToggleResizeIncrements => "Use resize increments when resizing window",
@@ -1119,6 +1197,8 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("Q", ModifiersState::CONTROL, Action::CloseWindow),
    Binding::new("H", ModifiersState::CONTROL, Action::PrintHelp),
    Binding::new("F", ModifiersState::CONTROL, Action::ToggleFullscreen),
+    #[cfg(macos_platform)]
+    Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
    Binding::new("D", ModifiersState::CONTROL, Action::ToggleDecorations),
    Binding::new("I", ModifiersState::CONTROL, Action::ToggleImeInput),
    Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
--- a/examples/x11_embed.rs
+++ b/examples/x11_embed.rs
@@ -13,39 +13,28 @@ fn main() -> Result<(), Box<dyn Error>> {
    mod fill;

    pub struct XEmbedDemo {
-        parent_window_id: u32,
-        window: Option<Box<dyn Window>>,
+        window: Box<dyn Window>,
    }

    impl ApplicationHandler for XEmbedDemo {
-        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let window_attributes = WindowAttributes::default()
-                .with_title("An embedded window!")
-                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0))
-                .with_embed_parent_window(self.parent_window_id);
-
-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
-        }
-
        fn window_event(
            &mut self,
            event_loop: &dyn ActiveEventLoop,
            _window_id: WindowId,
            event: WindowEvent,
        ) {
-            let window = self.window.as_ref().unwrap();
            match event {
                WindowEvent::CloseRequested => event_loop.exit(),
                WindowEvent::RedrawRequested => {
-                    window.pre_present_notify();
-                    fill::fill_window(window.as_ref());
+                    self.window.pre_present_notify();
+                    fill::fill_window(&*self.window);
                },
                _ => (),
            }
        }

        fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            self.window.as_ref().unwrap().request_redraw();
+            self.window.request_redraw();
        }
    }

@@ -58,7 +47,15 @@ fn main() -> Result<(), Box<dyn Error>> {
    tracing_subscriber::fmt::init();
    let event_loop = EventLoop::new()?;

-    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, window: None })?)
+    Ok(event_loop.run(|event_loop| {
+        let window_attributes = WindowAttributes::default()
+            .with_title("An embedded window!")
+            .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+            .with_embed_parent_window(parent_window_id);
+
+        let window = event_loop.create_window(window_attributes).unwrap();
+        XEmbedDemo { window }
+    })?)
 }

 #[cfg(not(x11_platform))]
--- a/src/application.rs
+++ b/src/application.rs
@@ -2,9 +2,13 @@

 use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
 use crate::event_loop::ActiveEventLoop;
+#[cfg(any(docsrs, macos_platform))]
+use crate::platform::macos::ApplicationHandlerExtMacOS;
 use crate::window::WindowId;

 /// The handler of the application events.
+///
+/// This is [dropped][std::ops::Drop] when the event loop is being shut down.
 pub trait ApplicationHandler {
    /// Emitted when new events arrive from the OS to be processed.
    ///
@@ -41,11 +45,21 @@ pub trait ApplicationHandler {
    /// [`pageshow`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pageshow_event
    /// [`bfcache`]: https://web.dev/bfcache/
    ///
+    /// ### Android
+    ///
+    /// On Android, the [`resumed()`] method is called when the `Activity` is (again, if after a
+    /// prior [`suspended()`]) being displayed to the user. This is a good place to begin drawing
+    /// visual elements, running animations, etc. It is driven by Android's [`onStart()`] method.
+    ///
+    /// [`onStart()`]: https://developer.android.com/reference/android/app/Activity#onStart()
+    ///
    /// ### Others
    ///
-    /// **Android / macOS / Orbital / Wayland / Windows / X11:** Unsupported.
+    /// **macOS / Orbital / Wayland / Windows / X11:** Unsupported.
    ///
-    /// [`resumed()`]: Self::resumed
+    /// [`resumed()`]: Self::resumed()
+    /// [`suspended()`]: Self::suspended()
+    /// [`exiting()`]: Self::exiting()
    fn resumed(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }
@@ -71,27 +85,27 @@ pub trait ApplicationHandler {
    ///
    /// ### Android
    ///
-    /// On Android, the [`can_create_surfaces()`] method is called when a new [`SurfaceView`] has
-    /// been created. This is expected to closely correlate with the [`onResume`] lifecycle
-    /// event but there may technically be a discrepancy.
+    /// On Android, the [`can_create_surfaces()`] method is called when a new [`NativeWindow`]
+    /// (native [`Surface`]) is created which backs the application window. This is expected to
+    /// closely correlate with the [`onStart`] lifecycle event which typically results in a surface
+    /// to be created after the app becomes visible.
    ///
-    /// [`onResume`]: https://developer.android.com/reference/android/app/Activity#onResume()
-    ///
-    /// Applications that need to run on Android must wait until they have been "resumed" before
+    /// Applications that need to run on Android must wait until they have received a surface before
    /// they will be able to create a render surface (such as an `EGLSurface`, [`VkSurfaceKHR`]
-    /// or [`wgpu::Surface`]) which depend on having a [`SurfaceView`]. Applications must also
-    /// assume that if they are [suspended], then their render surfaces are invalid and should
-    /// be dropped.
+    /// or [`wgpu::Surface`]) which depend on having a [`NativeWindow`]. Applications must handle
+    /// [`destroy_surfaces()`], where their render surfaces are invalid and should be dropped.
    ///
-    /// [suspended]: Self::destroy_surfaces
-    /// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView
-    /// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle
+    /// [`NativeWindow`]: https://developer.android.com/ndk/reference/group/a-native-window
+    /// [`Surface`]: https://developer.android.com/reference/android/view/Surface
+    /// [`onStart`]: https://developer.android.com/reference/android/app/Activity#onStart()
    /// [`VkSurfaceKHR`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html
    /// [`wgpu::Surface`]: https://docs.rs/wgpu/latest/wgpu/struct.Surface.html
    ///
-    /// [`can_create_surfaces()`]: Self::can_create_surfaces
-    /// [`destroy_surfaces()`]: Self::destroy_surfaces
-    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop);
+    /// [`can_create_surfaces()`]: Self::can_create_surfaces()
+    /// [`destroy_surfaces()`]: Self::destroy_surfaces()
+    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+        let _ = event_loop;
+    }

    /// Called after a wake up is requested using [`EventLoopProxy::wake_up()`].
    ///
@@ -132,8 +146,6 @@ pub trait ApplicationHandler {
    ///     # ) {
    ///     # }
    ///     #
-    ///     # fn can_create_surfaces(&mut self, _event_loop: &dyn ActiveEventLoop) {}
-    ///     #
    ///     fn proxy_wake_up(&mut self, _event_loop: &dyn ActiveEventLoop) {
    ///         // Iterate current events, since wake-ups may have been merged.
    ///         //
@@ -152,8 +164,6 @@ pub trait ApplicationHandler {
    ///
    ///     let (sender, receiver) = mpsc::channel();
    ///
-    ///     let mut app = MyApp { receiver };
-    ///
    ///     // Send an event in a loop
    ///     let proxy = event_loop.create_proxy();
    ///     let background_thread = thread::spawn(move || {
@@ -172,9 +182,8 @@ pub trait ApplicationHandler {
    ///         }
    ///     });
    ///
-    ///     event_loop.run_app(&mut app)?;
+    ///     event_loop.run(|_event_loop| MyApp { receiver })?;
    ///
-    ///     drop(app);
    ///     background_thread.join().unwrap();
    ///
    ///     Ok(())
@@ -196,7 +205,7 @@ pub trait ApplicationHandler {
    fn device_event(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        event: DeviceEvent,
    ) {
        let _ = (event_loop, device_id, event);
@@ -235,18 +244,30 @@ pub trait ApplicationHandler {
    /// ### Web
    ///
    /// On Web, the [`suspended()`] method is called in response to a [`pagehide`] event if the
-    /// page is being restored from the [`bfcache`] (back/forward cache) - an in-memory cache that
+    /// page is being stored in the [`bfcache`] (back/forward cache) - an in-memory cache that
    /// stores a complete snapshot of a page (including the JavaScript heap) as the user is
    /// navigating away.
    ///
    /// [`pagehide`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event
    /// [`bfcache`]: https://web.dev/bfcache/
    ///
+    /// ### Android
+    ///
+    /// On Android, the [`suspended()`] method is called when the `Activity` is no longer visible
+    /// to the user. This is a good place to stop refreshing UI, running animations and other visual
+    /// things. It is driven by Android's [`onStop()`] method.
+    ///
+    /// After this event the application either receives [`resumed()`] again, or [`exiting()`].
+    ///
+    /// [`onStop()`]: https://developer.android.com/reference/android/app/Activity#onStop()
+    ///
    /// ### Others
    ///
-    /// **Android / macOS / Orbital / Wayland / Windows / X11:** Unsupported.
+    /// **macOS / Orbital / Wayland / Windows / X11:** Unsupported.
    ///
-    /// [`suspended()`]: Self::suspended
+    /// [`resumed()`]: Self::resumed()
+    /// [`suspended()`]: Self::suspended()
+    /// [`exiting()`]: Self::exiting()
    fn suspended(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }
@@ -259,24 +280,22 @@ pub trait ApplicationHandler {
    ///
    /// ### Android
    ///
-    /// On Android, the [`destroy_surfaces()`] method is called when the application's associated
-    /// [`SurfaceView`] is destroyed. This is expected to closely correlate with the [`onPause`]
-    /// lifecycle event but there may technically be a discrepancy.
+    /// On Android, the [`destroy_surfaces()`] method is called when the application's
+    /// [`NativeWindow`] (native [`Surface`]) is destroyed. This is expected to closely correlate
+    /// with the [`onStop`] lifecycle event which typically results in the surface to be destroyed
+    /// after the app becomes invisible.
    ///
-    /// [`onPause`]: https://developer.android.com/reference/android/app/Activity#onPause()
+    /// Applications that need to run on Android must be able to handle their underlying
+    /// [`SurfaceView`] being destroyed, which in turn indirectly invalidates any existing
+    /// render surfaces that may have been created outside of Winit (such as an `EGLSurface`,
+    /// [`VkSurfaceKHR`] or [`wgpu::Surface`]).
    ///
-    /// Applications that need to run on Android should assume their [`SurfaceView`] has been
-    /// destroyed, which indirectly invalidates any existing render surfaces that may have been
-    /// created outside of Winit (such as an `EGLSurface`, [`VkSurfaceKHR`] or [`wgpu::Surface`]).
+    /// This means that in this method, you must drop all render surfaces before the event callback
+    /// completes, and only re-create them in or after [`can_create_surfaces()`] is next recieved.
    ///
-    /// After being [suspended] on Android applications must drop all render surfaces before
-    /// the event callback completes, which may be re-created when the application is next
-    /// [resumed].
-    ///
-    /// [suspended]: Self::destroy_surfaces
-    /// [resumed]: Self::can_create_surfaces
-    /// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView
-    /// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle
+    /// [`NativeWindow`]: https://developer.android.com/ndk/reference/group/a-native-window
+    /// [`Surface`]: https://developer.android.com/reference/android/view/Surface
+    /// [`onStop`]: https://developer.android.com/reference/android/app/Activity#onStop()
    /// [`VkSurfaceKHR`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html
    /// [`wgpu::Surface`]: https://docs.rs/wgpu/latest/wgpu/struct.Surface.html
    ///
@@ -284,20 +303,12 @@ pub trait ApplicationHandler {
    ///
    /// - **iOS / macOS / Orbital / Wayland / Web / Windows / X11:** Unsupported.
    ///
-    /// [`can_create_surfaces()`]: Self::can_create_surfaces
-    /// [`destroy_surfaces()`]: Self::destroy_surfaces
+    /// [`can_create_surfaces()`]: Self::can_create_surfaces()
+    /// [`destroy_surfaces()`]: Self::destroy_surfaces()
    fn destroy_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }

-    /// Emitted when the event loop is being shut down.
-    ///
-    /// This is irreversible - if this method is called, it is guaranteed that the event loop
-    /// will exit right after.
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        let _ = event_loop;
-    }
-
    /// Emitted when the application has received a memory warning.
    ///
    /// ## Platform-specific
@@ -325,6 +336,15 @@ pub trait ApplicationHandler {
    fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }
+
+    /// The macOS-specific handler.
+    ///
+    /// The return value from this should not change at runtime.
+    #[cfg(any(docsrs, macos_platform))]
+    #[inline(always)]
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+        None
+    }
 }

 #[deny(clippy::missing_trait_methods)]
@@ -363,7 +383,7 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
    fn device_event(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        event: DeviceEvent,
    ) {
        (**self).device_event(event_loop, device_id, event);
@@ -384,15 +404,16 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
        (**self).destroy_surfaces(event_loop);
    }

-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
    #[inline]
    fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
        (**self).memory_warning(event_loop);
    }
+
+    #[cfg(any(docsrs, macos_platform))]
+    #[inline]
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+        (**self).macos_handler()
+    }
 }

 #[deny(clippy::missing_trait_methods)]
@@ -431,7 +452,7 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
    fn device_event(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        event: DeviceEvent,
    ) {
        (**self).device_event(event_loop, device_id, event);
@@ -452,13 +473,14 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
        (**self).destroy_surfaces(event_loop);
    }

-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
    #[inline]
    fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
        (**self).memory_warning(event_loop);
    }
+
+    #[cfg(any(docsrs, macos_platform))]
+    #[inline]
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+        (**self).macos_handler()
+    }
 }
--- a/src/changelog/unreleased.md
+++ b/src/changelog/unreleased.md
@@ -56,15 +56,27 @@ changelog entry.

  Keep in mind that handles do not auto-upgrade after permissions are granted and have to be
  re-created to make full use of this feature.
- Add `Touch::finger_id` with a new type `FingerId`.
- On Web and Windows, add `FingerIdExt*::is_primary()`, exposing a way to determine
-  the primary finger in a multi-touch interaction.
 - Implement `Clone`, `Copy`, `Debug`, `Deserialize`, `Eq`, `Hash`, `Ord`, `PartialEq`, `PartialOrd`
  and `Serialize` on many types.
 - Add `MonitorHandle::current_video_mode()`.
+- On Android, the soft keyboard can now be shown using `Window::set_ime_allowed`.
 - Add basic iOS IME support. The soft keyboard can now be shown using `Window::set_ime_allowed`.
+- Add `ApplicationHandlerExtMacOS` trait, and a `macos_handler` method to `ApplicationHandler` which returns a `dyn ApplicationHandlerExtMacOS` which allows for macOS specific extensions to winit.
+- Add a `standard_key_binding` method to the `ApplicationHandlerExtMacOS` trait. This allows handling of standard keybindings such as "go to end of line" on macOS.
 - On macOS, add `WindowExtMacOS::set_borderless_game` and `WindowAttributesExtMacOS::with_borderless_game`
  to fully disable the menu bar and dock in Borderless Fullscreen as commonly done in games.
+- On macOS, add `WindowExtMacOS::set_unified_titlebar` and `WindowAttributesExtMacOS::with_unified_titlebar`
+  to use a larger style of titlebar.
+- Add `WindowId::into_raw()` and `from_raw()`.
+- Add `PointerKind`, `PointerSource`, `ButtonSource`, `FingerId`, `primary` and `position` to all
+  pointer events as part of the pointer event overhaul.
+- Add `DeviceId::into_raw()` and `from_raw()`.
+- On X11, the `window` example now understands the `X11_VISUAL_ID` and `X11_SCREEN_ID` env
+  variables to test the respective modifiers of window creation.
+- Added `Window::surface_position`, which is the position of the surface inside the window.
+- Added `Window::safe_area`, which describes the area of the surface that is unobstructed.
+- On X11 and Wayland, improved scancode conversions for more obscure key codes.
+- On Windows, improved scancode conversions for more obscure key codes.

 ### Changed

@@ -83,14 +95,14 @@ changelog entry.
 - Changed `EventLoopProxy::send_event` to `EventLoopProxy::wake_up`, it now
  only wakes up the loop.
 - On X11, implement smooth resizing through the sync extension API.
- `ApplicationHandler::create|destroy_surfaces()` was split off from
+- `ApplicationHandler::can_create|destroy_surfaces()` was split off from
  `ApplicationHandler::resumed/suspended()`.

  `ApplicationHandler::can_create_surfaces()` should, for portability reasons
  to Android, be the only place to create render surfaces.

-  `ApplicationHandler::resumed/suspended()` are now only emitted by iOS and Web
-  and now signify actually resuming/suspending the application.
+  `ApplicationHandler::resumed/suspended()` are now only emitted by iOS, Web
+  and Android, and now signify actually resuming/suspending the application.
 - Rename `platform::web::*ExtWebSys` to `*ExtWeb`.
 - Change signature of `EventLoop::run_app`, `EventLoopExtPumpEvents::pump_app_events` and
  `EventLoopExtRunOnDemand::run_app_on_demand` to accept a `impl ApplicationHandler` directly,
@@ -124,6 +136,34 @@ changelog entry.
  - `Window::set_max_inner_size` to `set_max_surface_size`.

  To migrate, you can probably just replace all instances of `inner_size` with `surface_size` in your codebase.
+- Every event carrying a `DeviceId` now uses `Option<DeviceId>` instead. A `None` value signifies that the
+  device can't be uniquely identified.
+- Pointer `WindowEvent`s were overhauled. The new events can handle any type of pointer, serving as
+  a single pointer input source. Now your application can handle any pointer type without having to
+  explicitly handle e.g. `Touch`:
+  - Rename `CursorMoved` to `PointerMoved`.
+  - Rename `CursorEntered` to `PointerEntered`.
+  - Rename `CursorLeft` to `PointerLeft`.
+  - Rename `MouseInput` to `PointerButton`.
+  - Add `primary` to every `PointerEvent` as a way to identify discard non-primary pointers in a
+    multi-touch interaction.
+  - Add `position` to every `PointerEvent`.
+  - `PointerMoved` is **not sent** after `PointerEntered` anymore.
+  - Remove `Touch`, which is folded into the `Pointer*` events.
+  - New `PointerKind` added to `PointerEntered` and `PointerLeft`, signifying which pointer type is
+    the source of this event.
+  - New `PointerSource` added to `PointerMoved`, similar to `PointerKind` but holding additional
+    data.
+  - New `ButtonSource` added to `PointerButton`, similar to `PointerKind` but holding pointer type
+    specific buttons. Use `ButtonSource::mouse_button()` to easily normalize any pointer button
+    type to a generic mouse button.
+  - New `FingerId` added to `PointerKind::Touch` and `PointerSource::Touch` able to uniquely
+    identify a finger in a multi-touch interaction. Replaces the old `Touch::id`.
+  - In the same spirit rename `DeviceEvent::MouseMotion` to `PointerMotion`.
+  - Remove `Force::Calibrated::altitude_angle`.
+- On X11, use bottom-right corner for IME hotspot in `Window::set_ime_cursor_area`.
+- On macOS and iOS, no longer emit `ScaleFactorChanged` upon window creation.
+- On macOS, no longer emit `Focused` upon window creation.

 ### Removed

@@ -146,11 +186,27 @@ changelog entry.
  v0.5 support. v0.6 remains in place and is enabled by default.
 - Remove `DeviceEvent::Added` and `DeviceEvent::Removed`.
 - Remove `DeviceEvent::Motion` and `WindowEvent::AxisMotion`.
- Remove `Touch::id` in favor of `Touch::finger_id`.
 - Remove `MonitorHandle::size()` and `refresh_rate_millihertz()` in favor of
  `MonitorHandle::current_video_mode()`.
 - On Android, remove all `MonitorHandle` support instead of emitting false data.
+- Remove `impl From<u64> for WindowId` and `impl From<WindowId> for u64`. Replaced with
+  `WindowId::into_raw()` and `from_raw()`.
+- Remove `dummy()` from `WindowId` and `DeviceId`.
+- Remove `WindowEvent::Touch` and `Touch` in favor of the new `PointerKind`, `PointerSource` and
+ `ButtonSource` as part of the new pointer event overhaul.
+- Remove `Force::altitude_angle`.
+- Removed `Window::inner_position`, use the new `Window::surface_position` instead.

 ### Fixed

 - On Orbital, `MonitorHandle::name()` now returns `None` instead of a dummy name.
+- On macOS, fix `WindowEvent::Moved` sometimes being triggered unnecessarily on resize.
+- On macOS, package manifest definitions of `LSUIElement` will no longer be overridden with the
+  default activation policy, unless explicitly provided during initialization.
+- On macOS, fix crash when calling `drag_window()` without a left click present.
+- On X11, key events forward to IME anyway, even when it's disabled.
+- On Windows, make `ControlFlow::WaitUntil` work more precisely using `CREATE_WAITABLE_TIMER_HIGH_RESOLUTION`.
+- On X11, creating windows on screen that is not the first one (e.g. `DISPLAY=:0.1`) works again.
+- On X11, creating windows while passing `with_x11_screen(non_default_screen)` works again.
+- On X11, fix XInput handling that prevented a new window from getting the focus in some cases.
+- On iOS, fixed `SurfaceResized` and `Window::surface_size` not reporting the size of the actual surface.
--- a/src/event.rs
+++ b/src/event.rs
@@ -1,39 +1,4 @@
 //! The event enums and assorted supporting types.
-//!
-//! These are sent to the closure given to [`EventLoop::run_app(...)`], where they get
-//! processed and used to modify the program state. For more details, see the root-level
-//! documentation.
-//!
-//! Some of these events represent different "parts" of a traditional event-handling loop. You could
-//! approximate the basic ordering loop of [`EventLoop::run_app(...)`] like this:
-//!
-//! ```rust,ignore
-//! let mut start_cause = StartCause::Init;
-//!
-//! while !elwt.exiting() {
-//!     app.new_events(event_loop, start_cause);
-//!
-//!     for event in (window events, user events, device events) {
-//!         // This will pick the right method on the application based on the event.
-//!         app.handle_event(event_loop, event);
-//!     }
-//!
-//!     for window_id in (redraw windows) {
-//!         app.window_event(event_loop, window_id, RedrawRequested);
-//!     }
-//!
-//!     app.about_to_wait(event_loop);
-//!     start_cause = wait_if_necessary();
-//! }
-//!
-//! app.exiting(event_loop);
-//! ```
-//!
-//! This leaves out timing details like [`ControlFlow::WaitUntil`] but hopefully
-//! describes what happens in what order.
-//!
-//! [`EventLoop::run_app(...)`]: crate::event_loop::EventLoop::run_app
-//! [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
 use std::path::PathBuf;
 use std::sync::{Mutex, Weak};
 #[cfg(not(web_platform))]
@@ -63,51 +28,41 @@ use crate::window::{ActivationToken, Theme, WindowId};
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Event {
-    /// See [`ApplicationHandler::new_events`] for details.
+    /// See [`ApplicationHandler::new_events()`] for details.
    ///
-    /// [`ApplicationHandler::new_events`]: crate::application::ApplicationHandler::new_events
+    /// [`ApplicationHandler::new_events()`]: crate::application::ApplicationHandler::new_events()
    NewEvents(StartCause),

-    /// See [`ApplicationHandler::window_event`] for details.
+    /// See [`ApplicationHandler::window_event()`] for details.
    ///
-    /// [`ApplicationHandler::window_event`]: crate::application::ApplicationHandler::window_event
+    /// [`ApplicationHandler::window_event()`]: crate::application::ApplicationHandler::window_event()
    #[allow(clippy::enum_variant_names)]
    WindowEvent { window_id: WindowId, event: WindowEvent },

-    /// See [`ApplicationHandler::device_event`] for details.
+    /// See [`ApplicationHandler::device_event()`] for details.
    ///
-    /// [`ApplicationHandler::device_event`]: crate::application::ApplicationHandler::device_event
+    /// [`ApplicationHandler::device_event()`]: crate::application::ApplicationHandler::device_event()
    #[allow(clippy::enum_variant_names)]
-    DeviceEvent { device_id: DeviceId, event: DeviceEvent },
+    DeviceEvent { device_id: Option<DeviceId>, event: DeviceEvent },

-    /// See [`ApplicationHandler::suspended`] for details.
+    /// See [`ApplicationHandler::suspended()`] for details.
    ///
-    /// [`ApplicationHandler::suspended`]: crate::application::ApplicationHandler::suspended
+    /// [`ApplicationHandler::suspended()`]: crate::application::ApplicationHandler::suspended()
    Suspended,

-    /// See [`ApplicationHandler::can_create_surfaces`] for details.
+    /// See [`ApplicationHandler::resumed()`] for details.
    ///
-    /// [`ApplicationHandler::can_create_surfaces`]: crate::application::ApplicationHandler::can_create_surfaces
-    CreateSurfaces,
-
-    /// See [`ApplicationHandler::resumed`] for details.
-    ///
-    /// [`ApplicationHandler::resumed`]: crate::application::ApplicationHandler::resumed
+    /// [`ApplicationHandler::resumed()`]: crate::application::ApplicationHandler::resumed()
    Resumed,

-    /// See [`ApplicationHandler::about_to_wait`] for details.
+    /// See [`ApplicationHandler::about_to_wait()`] for details.
    ///
-    /// [`ApplicationHandler::about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
+    /// [`ApplicationHandler::about_to_wait()`]: crate::application::ApplicationHandler::about_to_wait()
    AboutToWait,

-    /// See [`ApplicationHandler::exiting`] for details.
+    /// See [`ApplicationHandler::memory_warning()`] for details.
    ///
-    /// [`ApplicationHandler::exiting`]: crate::application::ApplicationHandler::exiting
-    LoopExiting,
-
-    /// See [`ApplicationHandler::memory_warning`] for details.
-    ///
-    /// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning
+    /// [`ApplicationHandler::memory_warning()`]: crate::application::ApplicationHandler::memory_warning()
    MemoryWarning,

    /// User requested a wake up.
@@ -153,10 +108,16 @@ pub enum WindowEvent {
    /// Contains the new dimensions of the surface (can also be retrieved with
    /// [`Window::surface_size`]).
    ///
+    /// This event will not necessarily be emitted upon window creation, query
+    /// [`Window::surface_size`] if you need to determine the surface's initial size.
+    ///
    /// [`Window::surface_size`]: crate::window::Window::surface_size
    SurfaceResized(PhysicalSize<u32>),

-    /// The position of the window has changed. Contains the window's new position.
+    /// The position of the window has changed.
+    ///
+    /// Contains the window's new position in desktop coordinates (can also be retrieved with
+    /// [`Window::outer_position`]).
    ///
    /// ## Platform-specific
    ///
@@ -190,6 +151,9 @@ pub enum WindowEvent {
    /// The window gained or lost focus.
    ///
    /// The parameter is true if the window has gained focus, and false if it has lost focus.
+    ///
+    /// Windows are unfocused upon creation, but will usually be focused by the system soon
+    /// afterwards.
    Focused(bool),

    /// An event from the keyboard has been received.
@@ -199,7 +163,7 @@ pub enum WindowEvent {
    ///   numpad keys act as if NumLock wasn't active. When this is used, the OS sends fake key
    ///   events which are not marked as `is_synthetic`.
    KeyboardInput {
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        event: KeyEvent,

        /// If `true`, the event was generated synthetically by winit
@@ -226,52 +190,113 @@ pub enum WindowEvent {
    /// - **iOS / Android / Web / Orbital:** Unsupported.
    Ime(Ime),

-    /// The cursor has moved on the window.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-    ///
-    /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-    /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
-    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-    CursorMoved {
-        device_id: DeviceId,
+    /// The pointer has moved on the window.
+    PointerMoved {
+        device_id: Option<DeviceId>,

-        /// (x,y) coords in pixels relative to the top-left corner of the window. Because the range
-        /// of this data is limited by the display area and it may have been transformed by
-        /// the OS to implement effects such as cursor acceleration, it should not be used
-        /// to implement non-cursor-like interactions such as 3D camera control.
+        /// (x,y) coordinates in pixels relative to the top-left corner of the window. Because the
+        /// range of this data is limited by the display area and it may have been
+        /// transformed by the OS to implement effects such as pointer acceleration, it
+        /// should not be used to implement non-pointer-like interactions such as 3D camera
+        /// control. For that, consider [`DeviceEvent::PointerMotion`].
+        ///
+        /// ## Platform-specific
+        ///
+        /// **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
+        ///
+        /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
+        /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
+        /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
        position: PhysicalPosition<f64>,
+
+        /// Indicates whether the event is created by a primary pointer.
+        ///
+        /// A pointer is considered primary when it's a mouse, the first finger in a multi-touch
+        /// interaction, or an unknown pointer source.
+        primary: bool,
+
+        source: PointerSource,
    },

-    /// The cursor has entered the window.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-    ///
-    /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-    /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
-    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-    CursorEntered { device_id: DeviceId },
+    /// The pointer has entered the window.
+    PointerEntered {
+        device_id: Option<DeviceId>,

-    /// The cursor has left the window.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-    ///
-    /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-    /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
-    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-    CursorLeft { device_id: DeviceId },
+        /// The position of the pointer when it entered the window.
+        ///
+        /// ## Platform-specific
+        ///
+        /// - **Orbital: Always emits `(0., 0.)`.
+        /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
+        ///
+        /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
+        /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
+        /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
+        position: PhysicalPosition<f64>,
+
+        /// Indicates whether the event is created by a primary pointer.
+        ///
+        /// A pointer is considered primary when it's a mouse, the first finger in a multi-touch
+        /// interaction, or an unknown pointer source.
+        primary: bool,
+
+        kind: PointerKind,
+    },
+
+    /// The pointer has left the window.
+    PointerLeft {
+        device_id: Option<DeviceId>,
+
+        /// The position of the pointer when it left the window. The position reported can be
+        /// outside the bounds of the window.
+        ///
+        /// ## Platform-specific
+        ///
+        /// - **Orbital/Windows:** Always emits [`None`].
+        /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
+        ///
+        /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
+        /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
+        /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
+        position: Option<PhysicalPosition<f64>>,
+
+        /// Indicates whether the event is created by a primary pointer.
+        ///
+        /// A pointer is considered primary when it's a mouse, the first finger in a multi-touch
+        /// interaction, or an unknown pointer source.
+        primary: bool,
+
+        kind: PointerKind,
+    },

    /// A mouse wheel movement or touchpad scroll occurred.
-    MouseWheel { device_id: DeviceId, delta: MouseScrollDelta, phase: TouchPhase },
+    MouseWheel { device_id: Option<DeviceId>, delta: MouseScrollDelta, phase: TouchPhase },

    /// An mouse button press has been received.
-    MouseInput { device_id: DeviceId, state: ElementState, button: MouseButton },
+    PointerButton {
+        device_id: Option<DeviceId>,
+        state: ElementState,
+
+        /// The position of the pointer when the button was pressed.
+        ///
+        /// ## Platform-specific
+        ///
+        /// - **Orbital: Always emits `(0., 0.)`.
+        /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
+        ///
+        /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
+        /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
+        /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
+        position: PhysicalPosition<f64>,
+
+        /// Indicates whether the event is created by a primary pointer.
+        ///
+        /// A pointer is considered primary when it's a mouse, the first finger in a multi-touch
+        /// interaction, or an unknown pointer source.
+        primary: bool,
+
+        button: ButtonSource,
+    },

    /// Two-finger pinch gesture, often used for magnification.
    ///
@@ -280,7 +305,7 @@ pub enum WindowEvent {
    /// - Only available on **macOS** and **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PinchGesture {
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        /// Positive values indicate magnification (zooming in) and  negative
        /// values indicate shrinking (zooming out).
        ///
@@ -296,7 +321,7 @@ pub enum WindowEvent {
    /// - Only available on **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PanGesture {
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        /// Change in pixels of pan gesture from last update.
        delta: PhysicalPosition<f32>,
        phase: TouchPhase,
@@ -320,7 +345,7 @@ pub enum WindowEvent {
    ///
    /// - Only available on **macOS 10.8** and later, and **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
-    DoubleTapGesture { device_id: DeviceId },
+    DoubleTapGesture { device_id: Option<DeviceId> },

    /// Two-finger rotation gesture.
    ///
@@ -332,7 +357,7 @@ pub enum WindowEvent {
    /// - Only available on **macOS** and **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    RotationGesture {
-        device_id: DeviceId,
+        device_id: Option<DeviceId>,
        /// change in rotation in degrees
        delta: f32,
        phase: TouchPhase,
@@ -343,19 +368,7 @@ pub enum WindowEvent {
    /// At the moment, only supported on Apple forcetouch-capable macbooks.
    /// The parameters are: pressure level (value between 0 and 1 representing how hard the
    /// touchpad is being pressed) and stage (integer representing the click level).
-    TouchpadPressure { device_id: DeviceId, pressure: f32, stage: i64 },
-
-    /// Touch event has been received
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-    /// - **macOS:** Unsupported.
-    ///
-    /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-    /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
-    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-    Touch(Touch),
+    TouchpadPressure { device_id: Option<DeviceId>, pressure: f32, stage: i64 },

    /// The window's scale factor has changed.
    ///
@@ -368,7 +381,12 @@ pub enum WindowEvent {
    /// To update the window size, use the provided [`SurfaceSizeWriter`] handle. By default, the
    /// window is resized to the value suggested by the OS, but it can be changed to any value.
    ///
+    /// This event will not necessarily be emitted upon window creation, query
+    /// [`Window::scale_factor`] if you need to determine the window's initial scale factor.
+    ///
    /// For more information about DPI in general, see the [`dpi`] crate.
+    ///
+    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
    ScaleFactorChanged {
        scale_factor: f64,
        /// Handle to update surface size during scale changes.
@@ -420,16 +438,141 @@ pub enum WindowEvent {

    /// Emitted when a window should be redrawn.
    ///
-    /// This gets triggered in two scenarios:
+    /// This gets triggered in a few scenarios:
    /// - The OS has performed an operation that's invalidated the window's contents (such as
-    ///   resizing the window).
+    ///   resizing the window, or changing [the safe area]).
    /// - The application has explicitly requested a redraw via [`Window::request_redraw`].
    ///
    /// Winit will aggregate duplicate redraw requests into a single event, to
    /// help avoid duplicating rendering work.
+    ///
+    /// [the safe area]: crate::window::Window::safe_area
    RedrawRequested,
 }

+/// Represents the kind type of a pointer event.
+///
+/// ## Platform-specific
+///
+/// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
+/// system.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum PointerKind {
+    Mouse,
+    /// See [`PointerSource::Touch`] for more details.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **macOS:** Unsupported.
+    Touch(FingerId),
+    Unknown,
+}
+
+/// Represents the pointer type and its data for a pointer event.
+///
+/// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
+/// system.
+#[derive(Clone, Debug, PartialEq)]
+pub enum PointerSource {
+    Mouse,
+    /// Represents a touch event.
+    ///
+    /// Every time the user touches the screen, a [`WindowEvent::PointerEntered`] and a
+    /// [`WindowEvent::PointerButton`] with [`ElementState::Pressed`] event with an unique
+    /// identifier for the finger is emitted. When a finger is lifted, a
+    /// [`WindowEvent::PointerButton`] with [`ElementState::Released`] and a
+    /// [`WindowEvent::PointerLeft`] event is generated with the same [`FingerId`].
+    ///
+    /// After a [`WindowEvent::PointerEntered`] event has been emitted, there may be zero or more
+    /// [`WindowEvent::PointerMoved`] events when the finger is moved or the touch pressure
+    /// changes.
+    ///
+    /// A [`WindowEvent::PointerLeft`] without a [`WindowEvent::PointerButton`] with
+    /// [`ElementState::Released`] event is emitted when the system has canceled tracking this
+    /// touch, such as when the window loses focus, or on mobile devices if the user moves the
+    /// device against their face.
+    ///
+    /// The [`FingerId`] may be reused by the system after a [`WindowEvent::PointerLeft`] event.
+    /// The user should assume that a new [`WindowEvent::PointerEntered`] event received with the
+    /// same ID has nothing to do with the old finger and is a new finger.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **macOS:** Unsupported.
+    Touch {
+        finger_id: FingerId,
+
+        /// Describes how hard the screen was pressed. May be [`None`] if the hardware does not
+        /// support pressure sensitivity.
+        ///
+        /// ## Platform-specific
+        ///
+        /// - **MacOS / Orbital / Wayland / X11:** Always emits [`None`].
+        /// - **Android:** Will never be [`None`]. If the device doesn't support pressure
+        ///   sensitivity, force will either be 0.0 or 1.0. Also see the
+        ///   [android documentation](https://developer.android.com/reference/android/view/MotionEvent#AXIS_PRESSURE).#[derive(Debug, Clone, Copy, PartialEq)]
+        /// - **Web:** Will never be [`None`]. If the device doesn't support pressure sensitivity,
+        ///   force will be 0.5 when a button is pressed or 0.0 otherwise.
+        force: Option<Force>,
+    },
+    Unknown,
+}
+
+impl From<PointerSource> for PointerKind {
+    fn from(source: PointerSource) -> Self {
+        match source {
+            PointerSource::Mouse => Self::Mouse,
+            PointerSource::Touch { finger_id, .. } => Self::Touch(finger_id),
+            PointerSource::Unknown => Self::Unknown,
+        }
+    }
+}
+
+/// Represents the pointer type of a [`WindowEvent::PointerButton`].
+///
+/// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
+/// system.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ButtonSource {
+    Mouse(MouseButton),
+    /// See [`PointerSource::Touch`] for more details.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **macOS:** Unsupported.
+    Touch {
+        finger_id: FingerId,
+        force: Option<Force>,
+    },
+    Unknown(u16),
+}
+
+impl ButtonSource {
+    /// Convert any [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
+    /// special handling in an application, this method can be used to handle it like any generic
+    /// mouse input.
+    pub fn mouse_button(self) -> MouseButton {
+        match self {
+            ButtonSource::Mouse(mouse) => mouse,
+            ButtonSource::Touch { .. } => MouseButton::Left,
+            ButtonSource::Unknown(button) => match button {
+                0 => MouseButton::Left,
+                1 => MouseButton::Middle,
+                2 => MouseButton::Right,
+                3 => MouseButton::Back,
+                4 => MouseButton::Forward,
+                _ => MouseButton::Other(button),
+            },
+        }
+    }
+}
+
+impl From<MouseButton> for ButtonSource {
+    fn from(mouse: MouseButton) -> Self {
+        Self::Mouse(mouse)
+    }
+}
+
 /// Identifier of an input device.
 ///
 /// Whenever you receive an event arising from a particular input device, this event contains a
@@ -437,24 +580,23 @@ pub enum WindowEvent {
 /// on-screen cursor and keyboard focus) or physical. Virtual devices typically aggregate inputs
 /// from multiple physical devices.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId(pub(crate) platform_impl::DeviceId);
-
-impl Default for DeviceId {
-    fn default() -> Self {
-        Self::dummy()
-    }
-}
+pub struct DeviceId(i64);

 impl DeviceId {
-    /// Returns a dummy id, useful for unit testing.
+    /// Convert the [`DeviceId`] into the underlying integer.
    ///
-    /// # Notes
+    /// This is useful if you need to pass the ID across an FFI boundary, or store it in an atomic.
+    #[allow(dead_code)]
+    pub(crate) const fn into_raw(self) -> i64 {
+        self.0
+    }
+
+    /// Construct a [`DeviceId`] from the underlying integer.
    ///
-    /// The only guarantee made about the return value of this function is that
-    /// it will always be equal to itself and to future values returned by this function.
-    /// No other guarantees are made. This may be equal to a real `DeviceId`.
-    pub const fn dummy() -> Self {
-        DeviceId(platform_impl::DeviceId::dummy())
+    /// This should only be called with integers returned from [`DeviceId::into_raw`].
+    #[allow(dead_code)]
+    pub(crate) const fn from_raw(id: i64) -> Self {
+        Self(id)
    }
 }

@@ -463,18 +605,23 @@ impl DeviceId {
 /// Whenever a touch event is received it contains a `FingerId` which uniquely identifies the finger
 /// used for the current interaction.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId(pub(crate) platform_impl::FingerId);
+pub struct FingerId(pub(crate) usize);

 impl FingerId {
-    /// Returns a dummy id, useful for unit testing.
+    /// Convert the [`FingerId`] into the underlying integer.
    ///
-    /// # Notes
+    /// This is useful if you need to pass the ID across an FFI boundary, or store it in an atomic.
+    #[allow(dead_code)]
+    pub(crate) const fn into_raw(self) -> usize {
+        self.0
+    }
+
+    /// Construct a [`FingerId`] from the underlying integer.
    ///
-    /// The only guarantee made about the return value of this function is that
-    /// it will always be equal to itself and to future values returned by this function.
-    /// No other guarantees are made. This may be equal to a real `FingerId`.
-    pub const fn dummy() -> Self {
-        FingerId(platform_impl::FingerId::dummy())
+    /// This should only be called with integers returned from [`FingerId::into_raw`].
+    #[allow(dead_code)]
+    pub(crate) const fn from_raw(id: usize) -> Self {
+        Self(id)
    }
 }

@@ -483,7 +630,7 @@ impl FingerId {
 /// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera
 /// or first-person game controls. Many physical actions, such as mouse movement, can produce both
 /// device and window events. Because window events typically arise from virtual devices
-/// (corresponding to GUI cursors and keyboard focus) the device IDs may not match.
+/// (corresponding to GUI pointers and keyboard focus) the device IDs may not match.
 ///
 /// Note that these events are delivered regardless of input focus.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -491,7 +638,7 @@ pub enum DeviceEvent {
    /// Change in physical position of a pointing device.
    ///
    /// This represents raw, unfiltered physical motion. Not to be confused with
-    /// [`WindowEvent::CursorMoved`].
+    /// [`WindowEvent::PointerMoved`].
    ///
    /// ## Platform-specific
    ///
@@ -508,7 +655,7 @@ pub enum DeviceEvent {
    ///
    #[rustfmt::skip]
    /// [`CursorGrabMode::Locked`]: crate::window::CursorGrabMode::Locked
-    MouseMotion {
+    PointerMotion {
        /// (x, y) change in position in unspecified units.
        ///
        /// Different devices may use different units.
@@ -837,50 +984,6 @@ pub enum TouchPhase {
    Cancelled,
 }

-/// Represents a touch event
-///
-/// Every time the user touches the screen, a new [`TouchPhase::Started`] event with an unique
-/// identifier for the finger is generated. When the finger is lifted, an [`TouchPhase::Ended`]
-/// event is generated with the same finger id.
-///
-/// After a `Started` event has been emitted, there may be zero or more `Move`
-/// events when the finger is moved or the touch pressure changes.
-///
-/// The finger id may be reused by the system after an `Ended` event. The user
-/// should assume that a new `Started` event received with the same id has nothing
-/// to do with the old finger and is a new finger.
-///
-/// A [`TouchPhase::Cancelled`] event is emitted when the system has canceled tracking this
-/// touch, such as when the window loses focus, or on iOS if the user moves the
-/// device against their face.
-///
-/// ## Platform-specific
-///
-/// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-/// - **macOS:** Unsupported.
-///
-/// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-/// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
-/// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Touch {
-    pub device_id: DeviceId,
-    pub phase: TouchPhase,
-    pub location: PhysicalPosition<f64>,
-    /// Describes how hard the screen was pressed. May be `None` if the platform
-    /// does not support pressure sensitivity.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - Only available on **iOS** 9.0+, **Windows** 8+, **Web**, and **Android**.
-    /// - **Android**: This will never be [None]. If the device doesn't support pressure
-    ///   sensitivity, force will either be 0.0 or 1.0. Also see the
-    ///   [android documentation](https://developer.android.com/reference/android/view/MotionEvent#AXIS_PRESSURE).
-    pub force: Option<Force>,
-    /// Unique identifier of a finger.
-    pub finger_id: FingerId,
-}
-
 /// Describes the force of a touch event
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -901,12 +1004,6 @@ pub enum Force {
        /// The value of this field is sufficiently high to provide a wide
        /// dynamic range for values of the `force` field.
        max_possible_force: f64,
-        /// The altitude (in radians) of the stylus.
-        ///
-        /// A value of 0 radians indicates that the stylus is parallel to the
-        /// surface. The value of this property is Pi/2 when the stylus is
-        /// perpendicular to the surface.
-        altitude_angle: Option<f64>,
    },
    /// If the platform reports the force as normalized, we have no way of
    /// knowing how much pressure 1.0 corresponds to – we know it's the maximum
@@ -923,13 +1020,7 @@ impl Force {
    /// consistent across devices.
    pub fn normalized(&self) -> f64 {
        match self {
-            Force::Calibrated { force, max_possible_force, altitude_angle } => {
-                let force = match altitude_angle {
-                    Some(altitude_angle) => force / altitude_angle.sin(),
-                    None => *force,
-                };
-                force / max_possible_force
-            },
+            Force::Calibrated { force, max_possible_force } => force / max_possible_force,
            Force::Normalized(force) => *force,
        }
    }
@@ -1045,21 +1136,20 @@ mod tests {
        ($closure:expr) => {{
            #[allow(unused_mut)]
            let mut x = $closure;
-            let did = event::DeviceId::dummy();
-            let fid = event::FingerId::dummy();
+            let fid = event::FingerId::from_raw(0);

            #[allow(deprecated)]
            {
                use crate::event::Event::*;
                use crate::event::Ime::Enabled;
                use crate::event::WindowEvent::*;
+                use crate::event::{PointerKind, PointerSource};
                use crate::window::WindowId;

                // Mainline events.
-                let wid = WindowId::dummy();
+                let wid = WindowId::from_raw(0);
                x(NewEvents(event::StartCause::Init));
                x(AboutToWait);
-                x(LoopExiting);
                x(Suspended);
                x(Resumed);

@@ -1075,44 +1165,64 @@ mod tests {
                with_window_event(HoveredFile("x.txt".into()));
                with_window_event(HoveredFileCancelled);
                with_window_event(Ime(Enabled));
-                with_window_event(CursorMoved { device_id: did, position: (0, 0).into() });
+                with_window_event(PointerMoved {
+                    device_id: None,
+                    primary: true,
+                    position: (0, 0).into(),
+                    source: PointerSource::Mouse,
+                });
                with_window_event(ModifiersChanged(event::Modifiers::default()));
-                with_window_event(CursorEntered { device_id: did });
-                with_window_event(CursorLeft { device_id: did });
+                with_window_event(PointerEntered {
+                    device_id: None,
+                    primary: true,
+                    position: (0, 0).into(),
+                    kind: PointerKind::Mouse,
+                });
+                with_window_event(PointerLeft {
+                    primary: true,
+                    device_id: None,
+                    position: Some((0, 0).into()),
+                    kind: PointerKind::Mouse,
+                });
                with_window_event(MouseWheel {
-                    device_id: did,
+                    device_id: None,
                    delta: event::MouseScrollDelta::LineDelta(0.0, 0.0),
                    phase: event::TouchPhase::Started,
                });
-                with_window_event(MouseInput {
-                    device_id: did,
+                with_window_event(PointerButton {
+                    device_id: None,
+                    primary: true,
                    state: event::ElementState::Pressed,
-                    button: event::MouseButton::Other(0),
+                    position: (0, 0).into(),
+                    button: event::MouseButton::Other(0).into(),
+                });
+                with_window_event(PointerButton {
+                    device_id: None,
+                    primary: true,
+                    state: event::ElementState::Released,
+                    position: (0, 0).into(),
+                    button: event::ButtonSource::Touch {
+                        finger_id: fid,
+                        force: Some(event::Force::Normalized(0.0)),
+                    },
                });
                with_window_event(PinchGesture {
-                    device_id: did,
+                    device_id: None,
                    delta: 0.0,
                    phase: event::TouchPhase::Started,
                });
-                with_window_event(DoubleTapGesture { device_id: did });
+                with_window_event(DoubleTapGesture { device_id: None });
                with_window_event(RotationGesture {
-                    device_id: did,
+                    device_id: None,
                    delta: 0.0,
                    phase: event::TouchPhase::Started,
                });
                with_window_event(PanGesture {
-                    device_id: did,
+                    device_id: None,
                    delta: PhysicalPosition::<f32>::new(0.0, 0.0),
                    phase: event::TouchPhase::Started,
                });
-                with_window_event(TouchpadPressure { device_id: did, pressure: 0.0, stage: 0 });
-                with_window_event(Touch(event::Touch {
-                    device_id: did,
-                    phase: event::TouchPhase::Started,
-                    location: (0.0, 0.0).into(),
-                    finger_id: fid,
-                    force: Some(event::Force::Normalized(0.0)),
-                }));
+                with_window_event(TouchpadPressure { device_id: None, pressure: 0.0, stage: 0 });
                with_window_event(ThemeChanged(crate::window::Theme::Light));
                with_window_event(Occluded(true));
            }
@@ -1122,9 +1232,9 @@ mod tests {
                use event::DeviceEvent::*;

                let with_device_event =
-                    |dev_ev| x(event::Event::DeviceEvent { device_id: did, event: dev_ev });
+                    |dev_ev| x(event::Event::DeviceEvent { device_id: None, event: dev_ev });

-                with_device_event(MouseMotion { delta: (0.0, 0.0).into() });
+                with_device_event(PointerMotion { delta: (0.0, 0.0).into() });
                with_device_event(MouseWheel {
                    delta: event::MouseScrollDelta::LineDelta(0.0, 0.0),
                });
@@ -1147,15 +1257,10 @@ mod tests {
        let force = event::Force::Normalized(0.0);
        assert_eq!(force.normalized(), 0.0);

-        let force2 =
-            event::Force::Calibrated { force: 5.0, max_possible_force: 2.5, altitude_angle: None };
+        let force2 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
        assert_eq!(force2.normalized(), 2.0);

-        let force3 = event::Force::Calibrated {
-            force: 5.0,
-            max_possible_force: 2.5,
-            altitude_angle: Some(std::f64::consts::PI / 2.0),
-        };
+        let force3 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
        assert_eq!(force3.normalized(), 2.0);
    }

@@ -1163,33 +1268,22 @@ mod tests {
    #[test]
    fn ensure_attrs_do_not_panic() {
        foreach_event!(|event: event::Event| {
-            let _ = format!("{:?}", event);
+            let _ = format!("{event:?}");
        });
        let _ = event::StartCause::Init.clone();

-        let did = crate::event::DeviceId::dummy().clone();
-        let fid = crate::event::FingerId::dummy().clone();
-        HashSet::new().insert(did);
-        let mut set = [did, did, did];
+        let fid = crate::event::FingerId::from_raw(0).clone();
+        HashSet::new().insert(fid);
+        let mut set = [fid, fid, fid];
        set.sort_unstable();
        let mut set2 = BTreeSet::new();
-        set2.insert(did);
-        set2.insert(did);
+        set2.insert(fid);
+        set2.insert(fid);

        HashSet::new().insert(event::TouchPhase::Started.clone());
        HashSet::new().insert(event::MouseButton::Left.clone());
        HashSet::new().insert(event::Ime::Enabled);

-        let _ = event::Touch {
-            device_id: did,
-            phase: event::TouchPhase::Started,
-            location: (0.0, 0.0).into(),
-            finger_id: fid,
-            force: Some(event::Force::Normalized(0.0)),
-        }
-        .clone();
-        let _ =
-            event::Force::Calibrated { force: 0.0, max_possible_force: 0.0, altitude_angle: None }
-                .clone();
+        let _ = event::Force::Calibrated { force: 0.0, max_possible_force: 0.0 }.clone();
    }
 }
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -13,9 +13,11 @@ use std::marker::PhantomData;
 #[cfg(any(x11_platform, wayland_platform))]
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::Arc;
 #[cfg(not(web_platform))]
 use std::time::{Duration, Instant};

+use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};
 #[cfg(web_platform)]
 use web_time::{Duration, Instant};

@@ -72,7 +74,7 @@ impl EventLoopBuilder {
    /// Attempting to create the event loop off the main 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.
-    /// `EventLoopBuilderExt::any_thread` functions are exposed in the relevant
+    /// `EventLoopBuilderExt::with_any_thread` functions are exposed in the relevant
    /// [`platform`] module if the target platform supports creating an event
    /// loop on any thread.
    ///
@@ -148,12 +150,11 @@ pub enum ControlFlow {
    /// When the current loop iteration finishes, suspend the thread until either another event
    /// arrives or the given time is reached.
    ///
-    /// Useful for implementing efficient timers, but should not be relied on for real-time needs
-    /// like rendering (VSync) or audio. Applications which want to render at the display's native
-    /// refresh rate should instead issue a [`Window::request_redraw`] at the end of
-    /// [`WindowEvent::RedrawRequested`].
+    /// Useful for implementing efficient timers. Applications which want to render at the
+    /// display's native refresh rate should instead use [`Poll`] and the VSync functionality
+    /// of a graphics API to reduce odds of missed frames.
    ///
-    /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested
+    /// [`Poll`]: Self::Poll
    WaitUntil(Instant),
 }

@@ -194,10 +195,48 @@ impl EventLoop {
 }

 impl EventLoop {
-    /// Run the application with the event loop on the calling thread.
+    /// Run the event loop on the current thread.
+    ///
+    /// You pass in a closure that returns your application state. This closure has access to the
+    /// currently running event loop, allowing you to initialize your windows and surfaces in here.
    ///
    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
    ///
+    /// ## Event loop flow
+    ///
+    /// This function internally handles the different parts of a traditional event-handling loop.
+    /// You could imagine this method being implemented like this:
+    ///
+    /// ```rust,ignore
+    /// // Initialize.
+    /// let mut app = init_closure(event_loop);
+    /// let mut start_cause = StartCause::Init;
+    ///
+    /// // Run loop.
+    /// while !elwt.exiting() {
+    ///     // Wake up.
+    ///     app.new_events(event_loop, start_cause);
+    ///
+    ///     // Handle events by the user.
+    ///     for (device_id, event) in incoming_device_events {
+    ///         app.device_event(event_loop, device_id, event);
+    ///     }
+    ///     for (window_id, event) in incoming_window_events {
+    ///         app.window_event(event_loop, window_id, event);
+    ///     }
+    ///
+    ///     // Done handling events, wait until we're woken up again.
+    ///     app.about_to_wait(event_loop);
+    ///     start_cause = wait_if_necessary();
+    /// }
+    ///
+    /// // Finished running, drop application state.
+    /// drop(app);
+    /// ```
+    ///
+    /// This is of course a very coarse-grained overview, and leaves out timing details like
+    /// [`ControlFlow::WaitUntil`] and life-cycle methods like [`ApplicationHandler::resumed`].
+    ///
    /// ## Platform-specific
    ///
    /// - **iOS:** Will never return to the caller and so values not passed to this function will
@@ -212,7 +251,7 @@ impl EventLoop {
        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
    )]
    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  `EventLoopExtWeb::spawn_app()`")]
-    ///   [^1] instead of [`run_app()`] to avoid the need for the Javascript exception trick, and to
+    ///   [^1] instead of [`run()`] to avoid the need for the Javascript exception trick, and to
    ///   make   it clearer that the event loop runs asynchronously (via the browser's own,
    ///   internal, event   loop) and doesn't block the current thread of execution like it does
    ///   on other platforms.
@@ -222,11 +261,20 @@ impl EventLoop {
    /// [^1]: `spawn_app()` is only available on the Web platform.
    ///
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    /// [`run_app()`]: Self::run_app()
+    /// [`run()`]: Self::run()
    #[inline]
    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    pub fn run<A: ApplicationHandler>(
+        self,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.event_loop.run(init_closure)
+    }
+
+    /// Run the event loop with the given application state.
+    #[deprecated = "less flexible version of `run`"]
    pub fn run_app<A: ApplicationHandler>(self, app: A) -> Result<(), EventLoopError> {
-        self.event_loop.run_app(app)
+        self.run(|_event_loop| app)
    }

    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
@@ -274,10 +322,9 @@ impl EventLoop {
    }
 }

-#[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for EventLoop {
-    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
-        rwh_06::HasDisplayHandle::display_handle(self.event_loop.window_target().rwh_06_handle())
+impl HasDisplayHandle for EventLoop {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        HasDisplayHandle::display_handle(self.event_loop.window_target().rwh_06_handle())
    }
 }

@@ -392,9 +439,7 @@ pub trait ActiveEventLoop: AsAny {
    /// Gets the current [`ControlFlow`].
    fn control_flow(&self) -> ControlFlow;

-    /// This exits the event loop.
-    ///
-    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
+    /// This stops the event loop.
    fn exit(&self);

    /// Returns if the [`EventLoop`] is about to stop.
@@ -408,20 +453,18 @@ pub trait ActiveEventLoop: AsAny {
    fn owned_display_handle(&self) -> OwnedDisplayHandle;

    /// Get the raw-window-handle handle.
-    #[cfg(feature = "rwh_06")]
-    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle;
+    fn rwh_06_handle(&self) -> &dyn HasDisplayHandle;
 }

-#[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for dyn ActiveEventLoop + '_ {
-    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+impl HasDisplayHandle for dyn ActiveEventLoop + '_ {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
        self.rwh_06_handle().display_handle()
    }
 }

 /// A proxy for the underlying display handle.
 ///
-/// The purpose of this type is to provide a cheaply clonable handle to the underlying
+/// The purpose of this type is to provide a cheaply cloneable handle to the underlying
 /// display handle. This is often used by graphics APIs to connect to the underlying APIs.
 /// It is difficult to keep a handle to the [`EventLoop`] type or the [`ActiveEventLoop`]
 /// type. In contrast, this type involves no lifetimes and can be persisted for as long as
@@ -431,36 +474,55 @@ impl rwh_06::HasDisplayHandle for dyn ActiveEventLoop + '_ {
 ///
 /// - A zero-sized type that is likely optimized out.
 /// - A reference-counted pointer to the underlying type.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone)]
 pub struct OwnedDisplayHandle {
-    #[cfg_attr(not(feature = "rwh_06"), allow(dead_code))]
-    pub(crate) platform: platform_impl::OwnedDisplayHandle,
+    pub(crate) handle: Arc<dyn HasDisplayHandle>,
+}
+
+impl OwnedDisplayHandle {
+    pub(crate) fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
+        Self { handle }
+    }
+}
+
+impl HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        self.handle.display_handle()
+    }
 }

 impl fmt::Debug for OwnedDisplayHandle {
-    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
    }
 }

-#[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
-    #[inline]
-    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
-        let raw = self.platform.raw_display_handle_rwh_06()?;
-
-        // SAFETY: The underlying display handle should be safe.
-        let handle = unsafe { rwh_06::DisplayHandle::borrow_raw(raw) };
-
-        Ok(handle)
+impl PartialEq for OwnedDisplayHandle {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.display_handle(), other.display_handle()) {
+            (Ok(lhs), Ok(rhs)) => lhs == rhs,
+            _ => false,
+        }
    }
 }

+impl Eq for OwnedDisplayHandle {}
+
+pub(crate) trait EventLoopProxyProvider: Send + Sync {
+    /// See [`EventLoopProxy::wake_up`] for details.
+    fn wake_up(&self);
+}
+
 /// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
 #[derive(Clone)]
 pub struct EventLoopProxy {
-    pub(crate) event_loop_proxy: platform_impl::EventLoopProxy,
+    pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
+}
+
+impl fmt::Debug for EventLoopProxy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopProxy").finish_non_exhaustive()
+    }
 }

 impl EventLoopProxy {
@@ -480,13 +542,11 @@ impl EventLoopProxy {
    ///
    /// [#3687]: https://github.com/rust-windowing/winit/pull/3687
    pub fn wake_up(&self) {
-        self.event_loop_proxy.wake_up();
+        self.proxy.wake_up();
    }
-}

-impl fmt::Debug for EventLoopProxy {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ActiveEventLoop").finish_non_exhaustive()
+    pub(crate) fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
+        Self { proxy }
    }
 }

--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,19 +1,14 @@
 //! Winit is a cross-platform window creation and event loop management library.
 //!
-//! # Building windows
-//!
-//! Before you can create a [`Window`], you first need to build an [`EventLoop`]. This is done with
-//! the [`EventLoop::new()`] function.
-//!
-//! ```no_run
-//! use winit::event_loop::EventLoop;
-//! let event_loop = EventLoop::new().unwrap();
-//! ```
-//!
-//! Then you create a [`Window`] with [`create_window`].
-//!
 //! # Event handling
 //!
+//! Basically all of the functionality that Winit exposes requires an [`ActiveEventLoop`], which you
+//! can get access to by running an [`EventLoop`] using [`EventLoop::new()`] and
+//! [`EventLoop::run()`].
+//!
+//! Once it's running, you can create your [`Window`]s with [`ActiveEventLoop::create_window()`] by
+//! passing in the desired [`WindowAttributes`].
+//!
 //! Once a [`Window`] has been created, it will generate different *events*. A [`Window`] object can
 //! generate [`WindowEvent`]s when certain input events occur, such as a cursor moving over the
 //! window or a key getting pressed while the window is focused. Devices can generate
@@ -21,9 +16,10 @@
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
 //! [`DeviceEvent`].
 //!
-//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
-//! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`exiting()`] is called.
+//! You retrieve by implementing [`ApplicationHandler`] for a new type, which will be the state of
+//! your application. The methods in this trait will continuously receive events until
+//! [`ActiveEventLoop::exit()`] is used, at which point your application state will be dropped, and
+//! the application shuts down.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g Web, iOS) and works
@@ -44,19 +40,20 @@
 //! use winit::application::ApplicationHandler;
 //! use winit::event::WindowEvent;
 //! use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
-//! use winit::window::{Window, WindowId, WindowAttributes};
+//! use winit::window::{Window, WindowId};
 //!
-//! #[derive(Default)]
 //! struct App {
-//!     window: Option<Box<dyn Window>>,
+//!     window: Box<dyn Window>,
 //! }
 //!
 //! impl ApplicationHandler for App {
-//!     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-//!         self.window = Some(event_loop.create_window(WindowAttributes::default()).unwrap());
-//!     }
-//!
-//!     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, id: WindowId, event: WindowEvent) {
+//!     fn window_event(
+//!         &mut self,
+//!         event_loop: &dyn ActiveEventLoop,
+//!         id: WindowId,
+//!         event: WindowEvent,
+//!     ) {
+//!         // Called by `EventLoop::run` when a new event happens on the window.
 //!         match event {
 //!             WindowEvent::CloseRequested => {
 //!                 println!("The close button was pressed; stopping");
@@ -76,26 +73,45 @@
 //!                 // You only need to call this if you've determined that you need to redraw in
 //!                 // applications which do not always need to. Applications that redraw continuously
 //!                 // can render here instead.
-//!                 self.window.as_ref().unwrap().request_redraw();
-//!             }
+//!                 self.window.request_redraw();
+//!             },
 //!             _ => (),
 //!         }
 //!     }
 //! }
 //!
-//! let event_loop = EventLoop::new().unwrap();
+//! # // Intentionally use `fn main` for clarity
+//! fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     // Create a new event loop.
+//!     let event_loop = EventLoop::new()?;
 //!
-//! // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
-//! // dispatched any events. This is ideal for games and similar applications.
-//! event_loop.set_control_flow(ControlFlow::Poll);
+//!     // Configure settings before launching.
 //!
-//! // ControlFlow::Wait pauses the event loop if no events are available to process.
-//! // This is ideal for non-game applications that only update in response to user
-//! // input, and uses significantly less power/CPU time than ControlFlow::Poll.
-//! event_loop.set_control_flow(ControlFlow::Wait);
+//!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
+//!     // dispatched any events. This is ideal for games and similar applications.
+//!     event_loop.set_control_flow(ControlFlow::Poll);
 //!
-//! let mut app = App::default();
-//! event_loop.run_app(&mut app);
+//!     // ControlFlow::Wait pauses the event loop if no events are available to process.
+//!     // This is ideal for non-game applications that only update in response to user
+//!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
+//!     event_loop.set_control_flow(ControlFlow::Wait);
+//!
+//!     // Launch and begin running our event loop.
+//!     event_loop.run(|event_loop| {
+//!         // The event loop has launched, and we can initialize our UI state in this closure.
+//!
+//!         // Create a simple window with default attributes.
+//!         let window = event_loop
+//!             .create_window(Window::default_attributes())
+//!             .expect("failed creating window");
+//!
+//!         // Give our newly created application state to Winit, which will, when necessary, call
+//!         // the `ApplicationHandler` methods configured above.
+//!         App { window }
+//!     })?;
+//!
+//!     Ok(())
+//! }
 //! ```
 //!
 //! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
@@ -115,6 +131,45 @@
 //! [`visible` set to `false`][crate::window::WindowAttributes::with_visible] and explicitly make
 //! the window visible only once you're ready to render into it.
 //!
+//! There is another important concept you need to know about when drawing: the "safe area". This
+//! can be accessed with [`Window::safe_area`], and describes a rectangle in the surface that is not
+//! obscured by notches, the status bar, and so on. You should be drawing your background and
+//! non-important content on the entire surface, but restrict important content (such as
+//! interactable UIs, text, etc.) to only being drawn inside the safe area.
+//!
+//! [`Window::safe_area`]: crate::window::Window::safe_area
+//!
+//! # Coordinate systems
+//!
+//! Windowing systems use many different coordinate systems, and this is reflected in Winit as well;
+//! there are "desktop coordinates", which is the coordinates of a window or monitor relative to the
+//! desktop at large, "window coordinates" which is the coordinates of the surface, relative to the
+//! window, and finally "surface coordinates", which is the coordinates relative to the drawn
+//! surface. All of these coordinates are relative to the top-left corner of their respective
+//! origin.
+//!
+//! Most of the functionality in Winit works with surface coordinates, so usually you only need to
+//! concern yourself with those. In case you need to convert to some other coordinate system, Winit
+//! provides [`Window::surface_position`] and [`Window::surface_size`] to describe the surface's
+//! location in window coordinates, and Winit provides [`Window::outer_position`] and
+//! [`Window::outer_size`] to describe the window's location in desktop coordinates. Using these
+//! methods, you should be able to convert a position in one coordinate system to another.
+//!
+//! An overview of how these four methods fit together can be seen in the image below:
+#![doc = concat!("\n\n", include_str!("../docs/res/coordinate-systems-desktop.svg"), "\n\n")] // Rustfmt removes \n, adding them like this works around that.
+//! On mobile, the situation is usually a bit different; because of the smaller screen space,
+//! windows usually fill the whole screen at a time, and as such there is _rarely_ a difference
+//! between these three coordinate systems, although you should still strive to handle this, as
+//! they're still relevant in more niche area such as Mac Catalyst, or multi-tasking on tablets.
+//!
+//! This is illustrated in the image below, along with the safe area since it's often relevant on
+//! mobile.
+#![doc = concat!("\n\n", include_str!("../docs/res/coordinate-systems-mobile.svg"), "\n\n")] // Rustfmt removes \n, adding them like this works around that.
+//! [`Window::surface_position`]: crate::window::Window::surface_position
+//! [`Window::surface_size`]: crate::window::Window::surface_size
+//! [`Window::outer_position`]: crate::window::Window::outer_position
+//! [`Window::outer_size`]: crate::window::Window::outer_size
+//!
 //! # UI scaling
 //!
 //! UI scaling is important, go read the docs for the [`dpi`] crate for an
@@ -147,20 +202,77 @@
 //! See the [`platform`] module for documentation on platform-specific cargo
 //! features.
 //!
+//! # Platform/Architecture Support
+//!
+//! Platform support on `winit` has two tiers: Tier 1 and Tier 2.
+//!
+//! - Tier 1 is **guaranteed to work**. Targets in this tier are actively tested both in CI and by
+//!   maintainers.
+//! - Tier 2 is **guaranteed to build**. Code compilation is tested in CI, but deeper testing is not
+//!   done.
+//!
+//! Please open an issue if you would like to add a Tier 2 target, or if you would
+//! like a Tier 2 target moved to Tier 1.
+//!
+//! ## Tier 1 Targets
+//!
+//! |Target Name                    |Target Triple                       |APIs           |
+//! |-------------------------------|------------------------------------|---------------|
+//! |32-Bit x86 Windows with MSVC   |`i686-pc-windows-msvc`              |Win32          |
+//! |64-Bit x86 Windows with MSVC   |`x86_64-pc-windows-msvc`            |Win32          |
+//! |32-Bit x86 Windows with glibc  |`i686-pc-windows-gnu`               |Win32          |
+//! |64-Bit x86 Windows with glibc  |`x86_64-pc-windows-gnu`             |Win32          |
+//! |32-Bit x86 Linux with glibc    |`i686-unknown-linux-gnu`            |X11, Wayland   |
+//! |64-Bit x86 Linux with glibc    |`x86_64-unknown-linux-gnu`          |X11, Wayland   |
+//! |64-Bit ARM Android             |`aarch64-linux-android`             |Android        |
+//! |64-Bit x86 Redox OS            |`x86_64-unknown-redox`              |Orbital        |
+//! |32-Bit x86 Redox OS            |`i686-unknown-redox`                |Orbital        |
+//! |64-Bit ARM Redox OS            |`aarch64-unknown-redox`             |Orbital        |
+//! |64-bit x64 macOS               |`x86_64-apple-darwin`               |AppKit         |
+//! |64-bit ARM macOS               |`aarch64-apple-darwin`              |AppKit         |
+//! |32-bit Wasm Web browser        |`wasm32-unknown-unknown`            |`wasm-bindgen` |
+//!
+//! ## Tier 2 Targets
+//!
+//! |Target Name                         |Target Triple                       |APIs           |
+//! |------------------------------------|------------------------------------|---------------|
+//! |64-Bit ARM Windows with MSVC        |`aarch64-pc-windows-msvc`           |Win32          |
+//! |32-Bit x86 Windows 7 with MSVC      |`i686-win7-windows-msvc`            |Win32          |
+//! |64-Bit x86 Windows 7 with MSVC      |`x86_64-win7-windows-msvc`          |Win32          |
+//! |64-bit x86 Linux with Musl          |`x86_64-unknown-linux-musl`         |X11, Wayland   |
+//! |64-bit x86 Linux with 32-bit glibc  |`x86_64-unknown-linux-gnux32`       |X11, Wayland   |
+//! |64-bit x86 Android                  |`x86_64-linux-android`              |Android        |
+//! |64-bit x64 iOS                      |`x86_64-apple-ios`                  |UIKit          |
+//! |64-bit ARM iOS                      |`aarch64-apple-ios`                 |UIKit          |
+//! |64-bit ARM Mac Catalyst             |`aarch64-apple-ios-macabi`          |UIKit          |
+//! |32-bit x86 Android                  |`i686-linux-android`                |Android        |
+//! |64-bit x86 FreeBSD                  |`x86_64-unknown-freebsd`            |X11, Wayland   |
+//! |64-bit x86 NetBSD                   |`x86_64-unknown-netbsd`             |X11            |
+//! |32-bit x86 Linux with Musl          |`i686-unknown-linux-musl`           |X11, Wayland   |
+//! |64-bit RISC-V Linux with glibc      |`riscv64gc-unknown-linux-gnu`       |X11, Wayland   |
+//! |64-bit ARM Linux with glibc         |`aarch64-unknown-linux-gnu`         |X11, Wayland   |
+//! |64-bit ARM Linux with Musl          |`aarch64-unknown-linux-musl`        |X11, Wayland   |
+//! |64-bit PowerPC Linux with glibc     |`powerpc64le-unknown-linux-gnu`     |X11, Wayland   |
+//! |32-Bit ARM Linux with glibc         |`armv5te-unknown-linux-gnueabi`     |X11, Wayland   |
+//! |64-Bit Linux on IBM Supercomputers  |`s390x-unknown-linux-gnu`           |X11, Wayland   |
+//! |32-bit ARM Android                  |`arm-linux-androideabi`             |Android        |
+//! |64-bit SPARC Linux with glibc       |`sparc64-unknown-linux-gnu`         |X11, Wayland   |
+//!
+//! [`ActiveEventLoop`]: event_loop::ActiveEventLoop
 //! [`EventLoop`]: event_loop::EventLoop
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
-//! [`EventLoop::run_app()`]: event_loop::EventLoop::run_app
-//! [`exit()`]: event_loop::ActiveEventLoop::exit
+//! [`EventLoop::run()`]: event_loop::EventLoop::run
+//! [`ActiveEventLoop::exit()`]: event_loop::ActiveEventLoop::exit
 //! [`Window`]: window::Window
 //! [`WindowId`]: window::WindowId
 //! [`WindowAttributes`]: window::WindowAttributes
 //! [window_new]: window::Window::new
-//! [`create_window`]: event_loop::ActiveEventLoop::create_window
+//! [`ActiveEventLoop::create_window()`]: event_loop::ActiveEventLoop::create_window
 //! [`Window::id()`]: window::Window::id
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
+//! [`ApplicationHandler`]: application::ApplicationHandler
 //! [`Event::UserEvent`]: event::Event::UserEvent
-//! [`exiting()`]: crate::application::ApplicationHandler::exiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
 //! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.
@@ -174,11 +286,11 @@
 // doc
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![allow(clippy::missing_safety_doc)]
+#![warn(clippy::uninlined_format_args)]

 // Re-export DPI types so that users don't have to put it in Cargo.toml.
 #[doc(inline)]
 pub use dpi;
-#[cfg(feature = "rwh_06")]
 pub use rwh_06 as raw_window_handle;

 pub mod application;
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -141,8 +141,11 @@ impl MonitorHandle {
        self.inner.name()
    }

-    /// Returns the top-left corner position of the monitor relative to the larger full
-    /// screen area.
+    /// Returns the top-left corner position of the monitor in desktop coordinates.
+    ///
+    /// This position is in the same coordinate system as [`Window::outer_position`].
+    ///
+    /// [`Window::outer_position`]: crate::window::Window::outer_position
    ///
    /// ## Platform-specific
    ///
--- a/src/platform/macos.rs
+++ b/src/platform/macos.rs
@@ -65,7 +65,7 @@
 //!     let app = NSApplication::sharedApplication(mtm);
 //!     app.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
 //!
-//!     // event_loop.run_app(&mut my_app);
+//!     // event_loop.run(|event_loop| { ... })?;
 //!     Ok(())
 //! }
 //! ```
@@ -75,9 +75,10 @@ use std::os::raw::c_void;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};

+use crate::application::ApplicationHandler;
 use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
-use crate::window::{Window, WindowAttributes};
+use crate::window::{Window, WindowAttributes, WindowId};

 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
@@ -91,6 +92,9 @@ pub trait WindowExtMacOS {
    /// 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.
+    ///
+    /// Make sure you only draw your important content inside the safe area so that it does not
+    /// overlap with the notch on newer devices, see [`Window::safe_area`] for details.
    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool;

    /// Returns whether or not the window has shadow.
@@ -156,6 +160,13 @@ pub trait WindowExtMacOS {

    /// Getter for the [`WindowExtMacOS::set_borderless_game`].
    fn is_borderless_game(&self) -> bool;
+
+    /// Makes the titlebar bigger, effectively adding more space around the
+    /// window controls if the titlebar is invisible.
+    fn set_unified_titlebar(&self, unified_titlebar: bool);
+
+    /// Getter for the [`WindowExtMacOS::set_unified_titlebar`].
+    fn unified_titlebar(&self) -> bool;
 }

 impl WindowExtMacOS for dyn Window + '_ {
@@ -254,6 +265,18 @@ impl WindowExtMacOS for dyn Window + '_ {
        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.maybe_wait_on_main(|w| w.is_borderless_game())
    }
+
+    #[inline]
+    fn set_unified_titlebar(&self, unified_titlebar: bool) {
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.set_unified_titlebar(unified_titlebar))
+    }
+
+    #[inline]
+    fn unified_titlebar(&self) -> bool {
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.unified_titlebar())
+    }
 }

 /// Corresponds to `NSApplicationActivationPolicy`.
@@ -307,6 +330,8 @@ pub trait WindowAttributesExtMacOS {
    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self;
    /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
    fn with_borderless_game(self, borderless_game: bool) -> Self;
+    /// See [`WindowExtMacOS::set_unified_titlebar`] for details on what this means if set.
+    fn with_unified_titlebar(self, unified_titlebar: bool) -> Self;
 }

 impl WindowAttributesExtMacOS for WindowAttributes {
@@ -381,12 +406,21 @@ impl WindowAttributesExtMacOS for WindowAttributes {
        self.platform_specific.borderless_game = borderless_game;
        self
    }
+
+    #[inline]
+    fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
+        self.platform_specific.unified_titlebar = unified_titlebar;
+        self
+    }
 }

 pub trait EventLoopBuilderExtMacOS {
-    /// Sets the activation policy for the application.
+    /// Sets the activation policy for the application. If used, this will override
+    /// any relevant settings provided in the package manifest.
+    /// For instance, `with_activation_policy(ActivationPolicy::Regular)` will prevent
+    /// the application from running as an "agent", even if LSUIElement is set to true.
    ///
-    /// It is set to [`ActivationPolicy::Regular`] by default.
+    /// If unused, the Winit will honor the package manifest.
    ///
    /// # Example
    ///
@@ -438,7 +472,7 @@ pub trait EventLoopBuilderExtMacOS {
 impl EventLoopBuilderExtMacOS for EventLoopBuilder {
    #[inline]
    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
-        self.platform_specific.activation_policy = activation_policy;
+        self.platform_specific.activation_policy = Some(activation_policy);
        self
    }

@@ -545,3 +579,52 @@ pub enum OptionAsAlt {
    #[default]
    None,
 }
+
+/// Additional events on [`ApplicationHandler`] that are specific to macOS.
+///
+/// This can be registered with [`ApplicationHandler::macos_handler`].
+pub trait ApplicationHandlerExtMacOS: ApplicationHandler {
+    /// The system interpreted a keypress as a standard key binding command.
+    ///
+    /// Examples include inserting tabs and newlines, or moving the insertion point, see
+    /// [`NSStandardKeyBindingResponding`] for the full list of key bindings. They are often text
+    /// editing related.
+    ///
+    /// This corresponds to the [`doCommandBySelector:`] method on `NSTextInputClient`.
+    ///
+    /// The `action` parameter contains the string representation of the selector. Examples include
+    /// `"insertBacktab:"`, `"indent:"` and `"noop:"`.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// impl ApplicationHandlerExtMacOS for App {
+    ///     fn standard_key_binding(
+    ///         &mut self,
+    ///         event_loop: &dyn ActiveEventLoop,
+    ///         window_id: WindowId,
+    ///         action: &str,
+    ///     ) {
+    ///         match action {
+    ///             "moveBackward:" => self.cursor.position -= 1,
+    ///             "moveForward:" => self.cursor.position += 1,
+    ///             _ => {} // Ignore other actions
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// [`NSStandardKeyBindingResponding`]: https://developer.apple.com/documentation/appkit/nsstandardkeybindingresponding?language=objc
+    /// [`doCommandBySelector:`]: https://developer.apple.com/documentation/appkit/nstextinputclient/1438256-docommandbyselector?language=objc
+    #[doc(alias = "doCommandBySelector:")]
+    fn standard_key_binding(
+        &mut self,
+        event_loop: &dyn ActiveEventLoop,
+        window_id: WindowId,
+        action: &str,
+    ) {
+        let _ = event_loop;
+        let _ = window_id;
+        let _ = action;
+    }
+}
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -21,6 +21,7 @@ pub mod windows;
 #[cfg(any(x11_platform, docsrs))]
 pub mod x11;

+#[allow(unused_imports)]
 #[cfg(any(
    windows_platform,
    macos_platform,
--- a/src/platform/run_on_demand.rs
+++ b/src/platform/run_on_demand.rs
@@ -1,16 +1,14 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event_loop::EventLoop;
+use crate::event_loop::{ActiveEventLoop, EventLoop};
 #[cfg(doc)]
-use crate::{
-    event_loop::ActiveEventLoop, platform::pump_events::EventLoopExtPumpEvents, window::Window,
-};
+use crate::{platform::pump_events::EventLoopExtPumpEvents, window::Window};

 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
    /// Run the application with the event loop on the calling thread.
    ///
-    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
+    /// Unlike [`EventLoop::run`], this function accepts non-`'static` (i.e. non-`move`)
    /// closures and it is possible to return control back to the caller without
    /// consuming the `EventLoop` (by using [`exit()`]) and
    /// so the event loop can be re-run after it has exit.
@@ -23,7 +21,7 @@ pub trait EventLoopExtRunOnDemand {
    /// to while maintaining the full state of your application. (If you need something like this
    /// you can look at the [`EventLoopExtPumpEvents::pump_app_events()`] API)
    ///
-    /// Each time `run_app_on_demand` is called the startup sequence of `init`, followed by
+    /// Each time `run_on_demand` is called the startup sequence of `init`, followed by
    /// `resume` is being preserved.
    ///
    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
@@ -40,7 +38,7 @@ pub trait EventLoopExtRunOnDemand {
    ///   [^1] more than once instead).
    /// - No [`Window`] state can be carried between separate runs of the event loop.
    ///
-    /// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you
+    /// You are strongly encouraged to use [`EventLoop::run()`] for portability, unless you
    /// specifically need the ability to re-run a single event loop more than once
    ///
    /// # Supported Platforms
@@ -60,12 +58,18 @@ pub trait EventLoopExtRunOnDemand {
    ///
    /// [`exit()`]: ActiveEventLoop::exit()
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError>;
+    fn run_on_demand<A: ApplicationHandler>(
+        &mut self,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError>;
 }

 impl EventLoopExtRunOnDemand for EventLoop {
-    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError> {
-        self.event_loop.run_app_on_demand(app)
+    fn run_on_demand<A: ApplicationHandler>(
+        &mut self,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.event_loop.run_on_demand(init_closure)
    }
 }

--- a/src/platform/web.rs
+++ b/src/platform/web.rs
@@ -29,17 +29,16 @@
 //! The following APIs can't take them into account and will therefore provide inaccurate results:
 //! - [`WindowEvent::SurfaceResized`] and [`Window::(set_)surface_size()`]
 //! - [`WindowEvent::Occluded`]
-//! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`], and
-//!   [`WindowEvent::Touch`].
+//! - [`WindowEvent::PointerMoved`], [`WindowEvent::PointerEntered`] and
+//!   [`WindowEvent::PointerLeft`].
 //! - [`Window::set_outer_position()`]
 //!
 //! [`WindowEvent::SurfaceResized`]: crate::event::WindowEvent::SurfaceResized
 //! [`Window::(set_)surface_size()`]: crate::window::Window::surface_size
 //! [`WindowEvent::Occluded`]: crate::event::WindowEvent::Occluded
-//! [`WindowEvent::CursorMoved`]: crate::event::WindowEvent::CursorMoved
-//! [`WindowEvent::CursorEntered`]: crate::event::WindowEvent::CursorEntered
-//! [`WindowEvent::CursorLeft`]: crate::event::WindowEvent::CursorLeft
-//! [`WindowEvent::Touch`]: crate::event::WindowEvent::Touch
+//! [`WindowEvent::PointerMoved`]: crate::event::WindowEvent::PointerMoved
+//! [`WindowEvent::PointerEntered`]: crate::event::WindowEvent::PointerEntered
+//! [`WindowEvent::PointerLeft`]: crate::event::WindowEvent::PointerLeft
 //! [`Window::set_outer_position()`]: crate::window::Window::set_outer_position

 use std::cell::Ref;
@@ -58,7 +57,6 @@ use web_sys::HtmlCanvasElement;
 use crate::application::ApplicationHandler;
 use crate::cursor::CustomCursorSource;
 use crate::error::NotSupportedError;
-use crate::event::FingerId;
 use crate::event_loop::{ActiveEventLoop, EventLoop};
 use crate::monitor::MonitorHandle;
 use crate::platform_impl::PlatformCustomCursorSource;
@@ -192,10 +190,10 @@ pub trait EventLoopExtWeb {
    /// Initializes the winit event loop.
    ///
    /// Unlike
-    #[cfg_attr(all(web_platform, target_feature = "exception-handling"), doc = "`run_app()`")]
+    #[cfg_attr(all(web_platform, target_feature = "exception-handling"), doc = "`run()`")]
    #[cfg_attr(
        not(all(web_platform, target_feature = "exception-handling")),
-        doc = "[`run_app()`]"
+        doc = "[`run()`]"
    )]
    /// [^1], this returns immediately, and doesn't throw an exception in order to
    /// satisfy its [`!`] return type.
@@ -208,9 +206,9 @@ pub trait EventLoopExtWeb {
    ///
    #[cfg_attr(
        not(all(web_platform, target_feature = "exception-handling")),
-        doc = "[`run_app()`]: EventLoop::run_app()"
+        doc = "[`run()`]: EventLoop::run()"
    )]
-    /// [^1]: `run_app()` is _not_ available on Wasm when the target supports `exception-handling`.
+    /// [^1]: `run()` is _not_ available on Wasm when the target supports `exception-handling`.
    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);

    /// Sets the strategy for [`ControlFlow::Poll`].
@@ -781,16 +779,3 @@ impl Display for OrientationLockError {
 }

 impl Error for OrientationLockError {}
-
-/// Additional methods on [`FingerId`] that are specific to Web.
-pub trait FingerIdExtWeb {
-    /// Indicates if the finger represents the first contact in a multi-touch interaction.
-    #[allow(clippy::wrong_self_convention)]
-    fn is_primary(self) -> bool;
-}
-
-impl FingerIdExtWeb for FingerId {
-    fn is_primary(self) -> bool {
-        self.0.is_primary()
-    }
-}
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -9,9 +9,11 @@ use std::path::Path;

 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+#[cfg(windows_platform)]
+use windows_sys::Win32::Foundation::HANDLE;

 use crate::dpi::PhysicalSize;
-use crate::event::{DeviceId, FingerId};
+use crate::event::DeviceId;
 use crate::event_loop::EventLoopBuilder;
 use crate::monitor::MonitorHandle;
 use crate::window::{BadIcon, Icon, Window, WindowAttributes};
@@ -133,7 +135,6 @@ impl<W: Window> Deref for AnyThread<W> {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl<W: Window> rwh_06::HasWindowHandle for AnyThread<W> {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        // SAFETY: The top level user has asserted this is only used safely.
@@ -335,7 +336,6 @@ pub trait WindowExtWindows {
    /// });
    /// # }
    /// ```
-    #[cfg(feature = "rwh_06")]
    unsafe fn window_handle_any_thread(
        &self,
    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError>;
@@ -399,7 +399,6 @@ impl WindowExtWindows for dyn Window + '_ {
        window.set_corner_preference(preference)
    }

-    #[cfg(feature = "rwh_06")]
    unsafe fn window_handle_any_thread(
        &self,
    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
@@ -433,16 +432,8 @@ pub trait WindowBorrowExtWindows: Borrow<dyn Window> + Sized {
    /// Win32 APIs.
    ///
    /// [`Window`]: crate::window::Window
-    #[cfg_attr(
-        feature = "rwh_06",
-        doc = "[`HasWindowHandle`]: rwh_06::HasWindowHandle",
-        doc = "[`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread"
-    )]
-    #[cfg_attr(
-        not(feature = "rwh_06"),
-        doc = "[`HasWindowHandle`]: #only-available-with-rwh_06",
-        doc = "[`window_handle_any_thread`]: #only-available-with-rwh_06"
-    )]
+    /// [`HasWindowHandle`]: rwh_06::HasWindowHandle
+    /// [`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread
    unsafe fn any_thread(self) -> AnyThread<Self>
    where
        Self: Window,
@@ -656,24 +647,15 @@ pub trait DeviceIdExtWindows {
    fn persistent_identifier(&self) -> Option<String>;
 }

+#[cfg(windows_platform)]
 impl DeviceIdExtWindows for DeviceId {
-    #[inline]
    fn persistent_identifier(&self) -> Option<String> {
-        self.0.persistent_identifier()
-    }
-}
-
-/// Additional methods on `FingerId` that are specific to Windows.
-pub trait FingerIdExtWindows {
-    /// Indicates if the finger represents the first contact in a multi-touch interaction.
-    #[allow(clippy::wrong_self_convention)]
-    fn is_primary(self) -> bool;
-}
-
-impl FingerIdExtWindows for FingerId {
-    #[inline]
-    fn is_primary(self) -> bool {
-        self.0.is_primary()
+        let raw_id = self.into_raw();
+        if raw_id != 0 {
+            crate::platform_impl::raw_input::get_raw_input_device_name(raw_id as HANDLE)
+        } else {
+            None
+        }
    }
 }

--- a/src/platform/x11.rs
+++ b/src/platform/x11.rs
@@ -80,9 +80,7 @@ pub type XWindow = u32;
 #[inline]
 pub fn register_xlib_error_hook(hook: XlibErrorHook) {
    // Append new hook.
-    unsafe {
-        crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
-    }
+    crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
 }

 /// Additional methods on [`ActiveEventLoop`] that are specific to X11.
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -13,18 +13,20 @@ use tracing::{debug, trace, warn};

 use crate::application::ApplicationHandler;
 use crate::cursor::Cursor;
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{EventLoopError, NotSupportedError, RequestError};
-use crate::event::{self, Force, StartCause, SurfaceSizeWriter};
+use crate::event::{self, DeviceId, FingerId, Force, StartCause, SurfaceSizeWriter};
 use crate::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform::pump_events::PumpStatus;
 use crate::window::{
    self, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, ImePurpose,
-    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowLevel,
+    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
+    WindowLevel,
 };

 mod keycodes;
@@ -106,6 +108,7 @@ pub struct EventLoop {
    running: bool,
    pending_redraw: bool,
    cause: StartCause,
+    primary_pointer: Option<FingerId>,
    ignore_volume_keys: bool,
    combining_accent: Option<char>,
 }
@@ -122,26 +125,31 @@ impl Default for PlatformSpecificEventLoopAttributes {
    }
 }

+// Android currently only supports one window
+const GLOBAL_WINDOW: WindowId = WindowId::from_raw(0);
+
 impl EventLoop {
    pub(crate) fn new(
        attributes: &PlatformSpecificEventLoopAttributes,
    ) -> Result<Self, EventLoopError> {
-        let proxy_wake_up = Arc::new(AtomicBool::new(false));
-
        let android_app = attributes.android_app.as_ref().expect(
            "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
             Android",
        );
+
+        let event_loop_proxy = Arc::new(EventLoopProxy::new(android_app.create_waker()));
+
        let redraw_flag = SharedFlag::new();

        Ok(Self {
            android_app: android_app.clone(),
+            primary_pointer: None,
            window_target: ActiveEventLoop {
                app: android_app.clone(),
                control_flow: Cell::new(ControlFlow::default()),
                exit: Cell::new(false),
                redraw_requester: RedrawRequester::new(&redraw_flag, android_app.create_waker()),
-                proxy_wake_up,
+                event_loop_proxy,
            },
            redraw_flag,
            loop_running: false,
@@ -187,22 +195,19 @@ impl EventLoop {
                },
                MainEvent::GainedFocus => {
                    HAS_FOCUS.store(true, Ordering::Relaxed);
-                    let window_id = window::WindowId(WindowId);
                    let event = event::WindowEvent::Focused(true);
-                    app.window_event(&self.window_target, window_id, event);
+                    app.window_event(&self.window_target, GLOBAL_WINDOW, event);
                },
                MainEvent::LostFocus => {
                    HAS_FOCUS.store(false, Ordering::Relaxed);
-                    let window_id = window::WindowId(WindowId);
                    let event = event::WindowEvent::Focused(false);
-                    app.window_event(&self.window_target, window_id, event);
+                    app.window_event(&self.window_target, GLOBAL_WINDOW, event);
                },
                MainEvent::ConfigChanged { .. } => {
                    let old_scale_factor = scale_factor(&self.android_app);
                    let scale_factor = scale_factor(&self.android_app);
                    if (scale_factor - old_scale_factor).abs() < f64::EPSILON {
                        let new_surface_size = Arc::new(Mutex::new(screen_size(&self.android_app)));
-                        let window_id = window::WindowId(WindowId);
                        let event = event::WindowEvent::ScaleFactorChanged {
                            surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(
                                &new_surface_size,
@@ -210,18 +215,18 @@ impl EventLoop {
                            scale_factor,
                        };

-                        app.window_event(&self.window_target, window_id, event);
+                        app.window_event(&self.window_target, GLOBAL_WINDOW, event);
                    }
                },
                MainEvent::LowMemory => {
                    app.memory_warning(&self.window_target);
                },
                MainEvent::Start => {
-                    // XXX: how to forward this state to applications?
-                    warn!("TODO: forward onStart notification to application");
+                    app.resumed(self.window_target());
                },
                MainEvent::Resume { .. } => {
                    debug!("App Resumed - is running");
+                    // TODO: This is incorrect - will be solved in https://github.com/rust-windowing/winit/pull/3897
                    self.running = true;
                },
                MainEvent::SaveState { .. } => {
@@ -231,11 +236,11 @@ impl EventLoop {
                },
                MainEvent::Pause => {
                    debug!("App Paused - stopped running");
+                    // TODO: This is incorrect - will be solved in https://github.com/rust-windowing/winit/pull/3897
                    self.running = false;
                },
                MainEvent::Stop => {
-                    // XXX: how to forward this state to applications?
-                    warn!("TODO: forward onStop notification to application");
+                    app.suspended(self.window_target());
                },
                MainEvent::Destroy => {
                    // XXX: maybe exit mainloop to drop things before being
@@ -273,7 +278,7 @@ impl EventLoop {
            },
        }

-        if self.window_target.proxy_wake_up.swap(false, Ordering::Relaxed) {
+        if self.window_target.event_loop_proxy.wake_up.swap(false, Ordering::Relaxed) {
            app.proxy_wake_up(&self.window_target);
        }

@@ -286,17 +291,15 @@ impl EventLoop {
                } else {
                    PhysicalSize::new(0, 0)
                };
-                let window_id = window::WindowId(WindowId);
                let event = event::WindowEvent::SurfaceResized(size);
-                app.window_event(&self.window_target, window_id, event);
+                app.window_event(&self.window_target, GLOBAL_WINDOW, event);
            }

            pending_redraw |= self.redraw_flag.get_and_reset();
            if pending_redraw {
                pending_redraw = false;
-                let window_id = window::WindowId(WindowId);
                let event = event::WindowEvent::RedrawRequested;
-                app.window_event(&self.window_target, window_id, event);
+                app.window_event(&self.window_target, GLOBAL_WINDOW, event);
            }
        }

@@ -315,50 +318,131 @@ impl EventLoop {
        let mut input_status = InputStatus::Handled;
        match event {
            InputEvent::MotionEvent(motion_event) => {
-                let window_id = window::WindowId(WindowId);
-                let device_id = event::DeviceId(DeviceId(motion_event.device_id()));
+                let device_id = Some(DeviceId::from_raw(motion_event.device_id() as i64));
+                let action = motion_event.action();

-                let phase = match motion_event.action() {
-                    MotionAction::Down | MotionAction::PointerDown => {
-                        Some(event::TouchPhase::Started)
-                    },
-                    MotionAction::Up | MotionAction::PointerUp => Some(event::TouchPhase::Ended),
-                    MotionAction::Move => Some(event::TouchPhase::Moved),
-                    MotionAction::Cancel => Some(event::TouchPhase::Cancelled),
-                    _ => {
-                        None // TODO mouse events
+                let pointers: Option<
+                    Box<dyn Iterator<Item = android_activity::input::Pointer<'_>>>,
+                > = match action {
+                    MotionAction::Down
+                    | MotionAction::PointerDown
+                    | MotionAction::Up
+                    | MotionAction::PointerUp => Some(Box::new(std::iter::once(
+                        motion_event.pointer_at_index(motion_event.pointer_index()),
+                    ))),
+                    MotionAction::Move | MotionAction::Cancel => {
+                        Some(Box::new(motion_event.pointers()))
                    },
+                    // TODO mouse events
+                    _ => None,
                };
-                if let Some(phase) = phase {
-                    let pointers: Box<dyn Iterator<Item = android_activity::input::Pointer<'_>>> =
-                        match phase {
-                            event::TouchPhase::Started | event::TouchPhase::Ended => {
-                                Box::new(std::iter::once(
-                                    motion_event.pointer_at_index(motion_event.pointer_index()),
-                                ))
-                            },
-                            event::TouchPhase::Moved | event::TouchPhase::Cancelled => {
-                                Box::new(motion_event.pointers())
-                            },
-                        };

-                    for pointer in pointers {
-                        let location =
-                            PhysicalPosition { x: pointer.x() as _, y: pointer.y() as _ };
-                        trace!(
-                            "Input event {device_id:?}, {phase:?}, loc={location:?}, \
-                             pointer={pointer:?}"
-                        );
+                for pointer in pointers.into_iter().flatten() {
+                    let tool_type = pointer.tool_type();
+                    let position = PhysicalPosition { x: pointer.x() as _, y: pointer.y() as _ };
+                    trace!(
+                        "Input event {device_id:?}, {action:?}, loc={position:?}, \
+                         pointer={pointer:?}, tool_type={tool_type:?}"
+                    );
+                    let finger_id = FingerId::from_raw(pointer.pointer_id() as usize);
+                    let force = Some(Force::Normalized(pointer.pressure() as f64));

-                        let event = event::WindowEvent::Touch(event::Touch {
-                            device_id,
-                            phase,
-                            location,
-                            finger_id: event::FingerId(FingerId(pointer.pointer_id())),
-                            force: Some(Force::Normalized(pointer.pressure() as f64)),
-                        });
+                    match action {
+                        MotionAction::Down | MotionAction::PointerDown => {
+                            let primary = action == MotionAction::Down;
+                            if primary {
+                                self.primary_pointer = Some(finger_id);
+                            }
+                            let event = event::WindowEvent::PointerEntered {
+                                device_id,
+                                primary,
+                                position,
+                                kind: match tool_type {
+                                    android_activity::input::ToolType::Finger => {
+                                        event::PointerKind::Touch(finger_id)
+                                    },
+                                    // TODO mouse events
+                                    android_activity::input::ToolType::Mouse => continue,
+                                    _ => event::PointerKind::Unknown,
+                                },
+                            };
+                            app.window_event(&self.window_target, GLOBAL_WINDOW, event);
+                            let event = event::WindowEvent::PointerButton {
+                                device_id,
+                                primary,
+                                state: event::ElementState::Pressed,
+                                position,
+                                button: match tool_type {
+                                    android_activity::input::ToolType::Finger => {
+                                        event::ButtonSource::Touch { finger_id, force }
+                                    },
+                                    // TODO mouse events
+                                    android_activity::input::ToolType::Mouse => continue,
+                                    _ => event::ButtonSource::Unknown(0),
+                                },
+                            };
+                            app.window_event(&self.window_target, GLOBAL_WINDOW, event);
+                        },
+                        MotionAction::Move => {
+                            let primary = self.primary_pointer == Some(finger_id);
+                            let event = event::WindowEvent::PointerMoved {
+                                device_id,
+                                primary,
+                                position,
+                                source: match tool_type {
+                                    android_activity::input::ToolType::Finger => {
+                                        event::PointerSource::Touch { finger_id, force }
+                                    },
+                                    // TODO mouse events
+                                    android_activity::input::ToolType::Mouse => continue,
+                                    _ => event::PointerSource::Unknown,
+                                },
+                            };
+                            app.window_event(&self.window_target, GLOBAL_WINDOW, event);
+                        },
+                        MotionAction::Up | MotionAction::PointerUp | MotionAction::Cancel => {
+                            let primary = action == MotionAction::Up
+                                || (action == MotionAction::Cancel
+                                    && self.primary_pointer == Some(finger_id));

-                        app.window_event(&self.window_target, window_id, event);
+                            if primary {
+                                self.primary_pointer = None;
+                            }
+
+                            if let MotionAction::Up | MotionAction::PointerUp = action {
+                                let event = event::WindowEvent::PointerButton {
+                                    device_id,
+                                    primary,
+                                    state: event::ElementState::Released,
+                                    position,
+                                    button: match tool_type {
+                                        android_activity::input::ToolType::Finger => {
+                                            event::ButtonSource::Touch { finger_id, force }
+                                        },
+                                        // TODO mouse events
+                                        android_activity::input::ToolType::Mouse => continue,
+                                        _ => event::ButtonSource::Unknown(0),
+                                    },
+                                };
+                                app.window_event(&self.window_target, GLOBAL_WINDOW, event);
+                            }
+
+                            let event = event::WindowEvent::PointerLeft {
+                                device_id,
+                                primary,
+                                position: Some(position),
+                                kind: match tool_type {
+                                    android_activity::input::ToolType::Finger => {
+                                        event::PointerKind::Touch(finger_id)
+                                    },
+                                    // TODO mouse events
+                                    android_activity::input::ToolType::Mouse => continue,
+                                    _ => event::PointerKind::Unknown,
+                                },
+                            };
+                            app.window_event(&self.window_target, GLOBAL_WINDOW, event);
+                        },
+                        _ => unreachable!(),
                    }
                }
            },
@@ -386,9 +470,8 @@ impl EventLoop {
                            &mut self.combining_accent,
                        );

-                        let window_id = window::WindowId(WindowId);
                        let event = event::WindowEvent::KeyboardInput {
-                            device_id: event::DeviceId(DeviceId(key.device_id())),
+                            device_id: Some(DeviceId::from_raw(key.device_id() as i64)),
                            event: event::KeyEvent {
                                state,
                                physical_key: keycodes::to_physical_key(keycode),
@@ -401,7 +484,7 @@ impl EventLoop {
                            is_synthetic: false,
                        };

-                        app.window_event(&self.window_target, window_id, event);
+                        app.window_event(&self.window_target, GLOBAL_WINDOW, event);
                    },
                }
            },
@@ -413,15 +496,21 @@ impl EventLoop {
        input_status
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<A: ApplicationHandler>(
+        mut self,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.run_on_demand(init_closure)
    }

-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_on_demand<A: ApplicationHandler>(
        &mut self,
-        mut app: A,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
    ) -> Result<(), EventLoopError> {
        self.window_target.clear_exit();
+
+        let mut app = init_closure(&self.window_target);
+
        loop {
            match self.pump_app_events(None, &mut app) {
                PumpStatus::Exit(0) => {
@@ -463,8 +552,6 @@ impl EventLoop {
        if self.exiting() {
            self.loop_running = false;

-            app.exiting(&self.window_target);
-
            PumpStatus::Exit(0)
        } else {
            PumpStatus::Continue
@@ -481,7 +568,8 @@ impl EventLoop {
        self.pending_redraw |= self.redraw_flag.get_and_reset();

        timeout = if self.running
-            && (self.pending_redraw || self.window_target.proxy_wake_up.load(Ordering::Relaxed))
+            && (self.pending_redraw
+                || self.window_target.event_loop_proxy.wake_up.load(Ordering::Relaxed))
        {
            // If we already have work to do then we don't want to block on the next poll
            Some(Duration::ZERO)
@@ -514,7 +602,7 @@ impl EventLoop {
                    self.pending_redraw |= self.redraw_flag.get_and_reset();
                    if !self.running
                        || (!self.pending_redraw
-                            && !self.window_target.proxy_wake_up.load(Ordering::Relaxed))
+                            && !self.window_target.event_loop_proxy.wake_up.load(Ordering::Relaxed))
                    {
                        return;
                    }
@@ -553,15 +641,20 @@ impl EventLoop {
    }
 }

-#[derive(Clone)]
 pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
+    wake_up: AtomicBool,
    waker: AndroidAppWaker,
 }

 impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, Ordering::Relaxed);
+    fn new(waker: AndroidAppWaker) -> Self {
+        Self { wake_up: AtomicBool::new(false), waker }
+    }
+}
+
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.wake_up.store(true, Ordering::Relaxed);
        self.waker.wake();
    }
 }
@@ -571,7 +664,7 @@ pub struct ActiveEventLoop {
    control_flow: Cell<ControlFlow>,
    exit: Cell<bool>,
    redraw_requester: RedrawRequester,
-    proxy_wake_up: Arc<AtomicBool>,
+    event_loop_proxy: Arc<EventLoopProxy>,
 }

 impl ActiveEventLoop {
@@ -581,12 +674,8 @@ impl ActiveEventLoop {
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> RootEventLoopProxy {
-        let event_loop_proxy = EventLoopProxy {
-            proxy_wake_up: self.proxy_wake_up.clone(),
-            waker: self.app.create_waker(),
-        };
-        RootEventLoopProxy { event_loop_proxy }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        CoreEventLoopProxy::new(self.event_loop_proxy.clone())
    }

    fn create_window(
@@ -633,17 +722,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
        self.exit.get()
    }

-    fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
-        RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(Arc::new(OwnedDisplayHandle))
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::AndroidDisplayHandle::new();
@@ -654,52 +741,10 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
 #[derive(Clone, PartialEq, Eq)]
 pub(crate) struct OwnedDisplayHandle;

-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::AndroidDisplayHandle::new().into())
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub(crate) struct WindowId;
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        WindowId
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(_: WindowId) -> Self {
-        0
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(_: u64) -> Self {
-        Self
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DeviceId(i32);
-
-impl DeviceId {
-    pub const fn dummy() -> Self {
-        DeviceId(0)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct FingerId(i32);
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId(0)
+impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::AndroidDisplayHandle::new();
+        Ok(unsafe { rwh_06::DisplayHandle::borrow_raw(raw.into()) })
    }
 }

@@ -729,7 +774,6 @@ impl Window {
        self.app.content_rect()
    }

-    #[cfg(feature = "rwh_06")]
    // Allow the usage of HasRawWindowHandle inside this function
    #[allow(deprecated)]
    fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
@@ -747,13 +791,11 @@ impl Window {
        }
    }

-    #[cfg(feature = "rwh_06")]
    fn raw_display_handle_rwh_06(&self) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
        Ok(rwh_06::RawDisplayHandle::Android(rwh_06::AndroidDisplayHandle::new()))
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_display_handle_rwh_06()?;
@@ -761,7 +803,6 @@ impl rwh_06::HasDisplayHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_window_handle_rwh_06()?;
@@ -770,8 +811,8 @@ impl rwh_06::HasWindowHandle for Window {
 }

 impl CoreWindow for Window {
-    fn id(&self) -> window::WindowId {
-        window::WindowId(WindowId)
+    fn id(&self) -> WindowId {
+        GLOBAL_WINDOW
    }

    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
@@ -796,8 +837,8 @@ impl CoreWindow for Window {

    fn pre_present_notify(&self) {}

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        Err(NotSupportedError::new("inner_position is not supported").into())
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        (0, 0).into()
    }

    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
@@ -820,6 +861,10 @@ impl CoreWindow for Window {
        screen_size(&self.app)
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        PhysicalInsets::new(0, 0, 0, 0)
+    }
+
    fn set_min_surface_size(&self, _: Option<Size>) {}

    fn set_max_surface_size(&self, _: Option<Size>) {}
@@ -886,7 +931,13 @@ impl CoreWindow for Window {

    fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}

-    fn set_ime_allowed(&self, _allowed: bool) {}
+    fn set_ime_allowed(&self, allowed: bool) {
+        if allowed {
+            self.app.show_soft_input(true);
+        } else {
+            self.app.hide_soft_input(true);
+        }
+    }

    fn set_ime_purpose(&self, _purpose: ImePurpose) {}

@@ -939,12 +990,10 @@ impl CoreWindow for Window {

    fn reset_dead_keys(&self) {}

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
--- a/src/platform_impl/apple/appkit/app.rs
+++ b/src/platform_impl/apple/appkit/app.rs
@@ -7,7 +7,6 @@ use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, N
 use objc2_foundation::{MainThreadMarker, NSObject};

 use super::app_state::AppState;
-use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};

 declare_class!(
@@ -61,7 +60,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {

            if delta_x != 0.0 || delta_y != 0.0 {
                app_state.maybe_queue_with_handler(move |app, event_loop| {
-                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
+                    app.device_event(event_loop, None, DeviceEvent::PointerMotion {
                        delta: (delta_x, delta_y),
                    });
                });
@@ -70,7 +69,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
        NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
            let button = unsafe { event.buttonNumber() } as u32;
            app_state.maybe_queue_with_handler(move |app, event_loop| {
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                app.device_event(event_loop, None, DeviceEvent::Button {
                    button,
                    state: ElementState::Pressed,
                });
@@ -79,7 +78,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
        NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
            let button = unsafe { event.buttonNumber() } as u32;
            app_state.maybe_queue_with_handler(move |app, event_loop| {
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                app.device_event(event_loop, None, DeviceEvent::Button {
                    button,
                    state: ElementState::Released,
                });
--- a/src/platform_impl/apple/appkit/app_state.rs
+++ b/src/platform_impl/apple/appkit/app_state.rs
@@ -1,30 +1,30 @@
 use std::cell::{Cell, OnceCell, RefCell};
 use std::mem;
 use std::rc::{Rc, Weak};
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::atomic::Ordering as AtomicOrdering;
 use std::sync::Arc;
 use std::time::Instant;

-use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy};
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSRunningApplication};
 use objc2_foundation::{MainThreadMarker, NSNotification};

 use super::super::event_handler::EventHandler;
-use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
+use super::event_loop::{stop_app_immediately, EventLoopProxy, PanicInfo};
+use super::menu;
 use super::observer::{EventLoopWaker, RunLoop};
-use super::{menu, WindowId};
 use crate::application::ApplicationHandler;
 use crate::event::{StartCause, WindowEvent};
-use crate::event_loop::ControlFlow;
-use crate::window::WindowId as RootWindowId;
+use crate::event_loop::{ActiveEventLoop, ControlFlow};
+use crate::window::WindowId;

 #[derive(Debug)]
 pub(super) struct AppState {
    mtm: MainThreadMarker,
-    activation_policy: NSApplicationActivationPolicy,
+    activation_policy: Option<NSApplicationActivationPolicy>,
    default_menu: bool,
    activate_ignoring_other_apps: bool,
    run_loop: RunLoop,
-    proxy_wake_up: Arc<AtomicBool>,
+    event_loop_proxy: Arc<EventLoopProxy>,
    event_handler: EventHandler,
    stop_on_launch: Cell<bool>,
    stop_before_wait: Cell<bool>,
@@ -65,14 +65,14 @@ static GLOBAL: StaticMainThreadBound<OnceCell<Rc<AppState>>> =
 impl AppState {
    pub(super) fn setup_global(
        mtm: MainThreadMarker,
-        activation_policy: NSApplicationActivationPolicy,
+        activation_policy: Option<NSApplicationActivationPolicy>,
        default_menu: bool,
        activate_ignoring_other_apps: bool,
    ) -> Rc<Self> {
        let this = Rc::new(AppState {
            mtm,
            activation_policy,
-            proxy_wake_up: Arc::new(AtomicBool::new(false)),
+            event_loop_proxy: Arc::new(EventLoopProxy::new()),
            default_menu,
            activate_ignoring_other_apps,
            run_loop: RunLoop::main(mtm),
@@ -113,7 +113,22 @@ impl AppState {
        // We need to delay setting the activation policy and activating the app
        // until `applicationDidFinishLaunching` has been called. Otherwise the
        // menu bar is initially unresponsive on macOS 10.15.
-        app.setActivationPolicy(self.activation_policy);
+        if let Some(activation_policy) = self.activation_policy {
+            app.setActivationPolicy(activation_policy);
+        } else {
+            // If no activation policy is explicitly provided, and the application
+            // is bundled, do not set the activation policy at all, to allow the
+            // package manifest to define the behavior via LSUIElement.
+            //
+            // See:
+            // - https://github.com/rust-windowing/winit/issues/261
+            // - https://github.com/rust-windowing/winit/issues/3958
+            let is_bundled =
+                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
+            if !is_bundled {
+                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
+            }
+        }

        #[allow(deprecated)]
        app.activateIgnoringOtherApps(self.activate_ignoring_other_apps);
@@ -148,21 +163,29 @@ impl AppState {
    pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
        trace_scope!("NSApplicationWillTerminateNotification");
        // TODO: Notify every window that it will be destroyed, like done in iOS?
+        self.with_handler(|app, event_loop| {
+            app.exiting(event_loop);
+        });
        self.internal_exit();
    }

    /// Place the event handler in the application state for the duration
    /// of the given closure.
-    pub fn set_event_handler<R>(
+    pub fn set_init_closure<A: ApplicationHandler, R>(
        &self,
-        handler: &mut dyn ApplicationHandler,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
        closure: impl FnOnce() -> R,
    ) -> R {
-        self.event_handler.set(handler, closure)
+        let init_closure = Box::new(
+            |active_event_loop: &'_ dyn ActiveEventLoop| -> Box<dyn ApplicationHandler + '_> {
+                Box::new(init_closure(active_event_loop))
+            },
+        );
+        self.event_handler.set(init_closure, closure)
    }

-    pub fn proxy_wake_up(&self) -> Arc<AtomicBool> {
-        self.proxy_wake_up.clone()
+    pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
+        &self.event_loop_proxy
    }

    /// If `pump_events` is called to progress the event loop then we
@@ -193,10 +216,6 @@ impl AppState {
    /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
    /// and we won't need to re-launch the app if subsequent EventLoops are run.
    pub fn internal_exit(self: &Rc<Self>) {
-        self.with_handler(|app, event_loop| {
-            app.exiting(event_loop);
-        });
-
        self.set_is_running(false);
        self.set_stop_on_redraw(false);
        self.set_stop_before_wait(false);
@@ -241,7 +260,7 @@ impl AppState {
        // -> Don't go back into the event handler when our callstack originates from there
        if !self.event_handler.in_use() {
            self.with_handler(|app, event_loop| {
-                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
+                app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
            });

            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
@@ -346,14 +365,14 @@ impl AppState {
            return;
        }

-        if self.proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+        if self.event_loop_proxy.wake_up.swap(false, AtomicOrdering::Relaxed) {
            self.with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
        }

        let redraw = mem::take(&mut *self.pending_redraw.borrow_mut());
        for window_id in redraw {
            self.with_handler(|app, event_loop| {
-                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
+                app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
            });
        }
        self.with_handler(|app, event_loop| {
--- a/src/platform_impl/apple/appkit/event_loop.rs
+++ b/src/platform_impl/apple/appkit/event_loop.rs
@@ -20,6 +20,7 @@ use objc2_app_kit::{
    NSApplicationWillTerminateNotification, NSWindow,
 };
 use objc2_foundation::{MainThreadMarker, NSNotificationCenter, NSObject, NSObjectProtocol};
+use rwh_06::HasDisplayHandle;

 use super::super::notification_center::create_observer;
 use super::app::WinitApplication;
@@ -32,7 +33,8 @@ use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, RequestError};
 use crate::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform::macos::ActivationPolicy;
@@ -95,9 +97,8 @@ impl ActiveEventLoop {
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> RootEventLoopProxy {
-        let event_loop_proxy = EventLoopProxy::new(self.app_state.proxy_wake_up());
-        RootEventLoopProxy { event_loop_proxy }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        CoreEventLoopProxy::new(self.app_state.event_loop_proxy().clone())
    }

    fn create_window(
@@ -151,17 +152,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
        self.app_state.exiting()
    }

-    fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
-        RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(Arc::new(OwnedDisplayHandle))
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::RawDisplayHandle::AppKit(rwh_06::AppKitDisplayHandle::new());
@@ -190,18 +189,14 @@ pub struct EventLoop {

 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) activation_policy: ActivationPolicy,
+    pub(crate) activation_policy: Option<ActivationPolicy>,
    pub(crate) default_menu: bool,
    pub(crate) activate_ignoring_other_apps: bool,
 }

 impl Default for PlatformSpecificEventLoopAttributes {
    fn default() -> Self {
-        Self {
-            activation_policy: Default::default(), // Regular
-            default_menu: true,
-            activate_ignoring_other_apps: true,
-        }
+        Self { activation_policy: None, default_menu: true, activate_ignoring_other_apps: true }
    }
 }

@@ -223,9 +218,10 @@ impl EventLoop {
        }

        let activation_policy = match attributes.activation_policy {
-            ActivationPolicy::Regular => NSApplicationActivationPolicy::Regular,
-            ActivationPolicy::Accessory => NSApplicationActivationPolicy::Accessory,
-            ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
+            None => None,
+            Some(ActivationPolicy::Regular) => Some(NSApplicationActivationPolicy::Regular),
+            Some(ActivationPolicy::Accessory) => Some(NSApplicationActivationPolicy::Accessory),
+            Some(ActivationPolicy::Prohibited) => Some(NSApplicationActivationPolicy::Prohibited),
        };

        let app_state = AppState::setup_global(
@@ -278,20 +274,23 @@ impl EventLoop {
        &self.window_target
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<A: ApplicationHandler>(
+        mut self,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.run_on_demand(init_closure)
    }

    // NB: we don't base this on `pump_events` because for `MacOs` we can't support
    // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
    // time and so a layered implementation would end up using a lot of CPU due to
    // redundant wake ups.
-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_on_demand<A: ApplicationHandler>(
        &mut self,
-        mut app: A,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
    ) -> Result<(), EventLoopError> {
        self.app_state.clear_exit();
-        self.app_state.set_event_handler(&mut app, || {
+        self.app_state.set_init_closure(init_closure, || {
            autoreleasepool(|_| {
                // clear / normalize pump_events state
                self.app_state.set_wait_timeout(None);
@@ -394,16 +393,12 @@ impl EventLoop {
    }
 }

-#[derive(Clone, PartialEq, Eq)]
 pub(crate) struct OwnedDisplayHandle;

-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::AppKitDisplayHandle::new().into())
+impl HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::RawDisplayHandle::AppKit(rwh_06::AppKitDisplayHandle::new());
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
    }
 }

@@ -442,8 +437,9 @@ pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
    }
 }

+#[derive(Debug)]
 pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
+    pub(crate) wake_up: AtomicBool,
    source: CFRunLoopSourceRef,
 }

@@ -458,14 +454,8 @@ impl Drop for EventLoopProxy {
    }
 }

-impl Clone for EventLoopProxy {
-    fn clone(&self) -> Self {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
-    }
-}
-
 impl EventLoopProxy {
-    fn new(proxy_wake_up: Arc<AtomicBool>) -> Self {
+    pub(crate) fn new() -> Self {
        unsafe {
            // just wake up the eventloop
            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -489,14 +479,16 @@ impl EventLoopProxy {
            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
            CFRunLoopWakeUp(rl);

-            EventLoopProxy { proxy_wake_up, source }
+            EventLoopProxy { wake_up: AtomicBool::new(false), source }
        }
    }
+}

-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.wake_up.store(true, AtomicOrdering::Relaxed);
        unsafe {
-            // let the main thread know there's a new event
+            // Let the main thread know there's a new event.
            CFRunLoopSourceSignal(self.source);
            let rl = CFRunLoopGetMain();
            CFRunLoopWakeUp(rl);
--- a/src/platform_impl/apple/appkit/mod.rs
+++ b/src/platform_impl/apple/appkit/mod.rs
@@ -17,34 +17,11 @@ mod window_delegate;
 pub(crate) use self::cursor::CustomCursor as PlatformCustomCursor;
 pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra};
 pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
-    PlatformSpecificEventLoopAttributes,
+    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
 };
 pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
-pub(crate) use self::window::{Window, WindowId};
+pub(crate) use self::window::Window;
 pub(crate) use self::window_delegate::PlatformSpecificWindowAttributes;
 pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::event::DeviceId as RootDeviceId;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId;
-
-impl DeviceId {
-    pub const 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);
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId;
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId
-    }
-}
--- a/src/platform_impl/apple/appkit/view.rs
+++ b/src/platform_impl/apple/appkit/view.rs
@@ -24,15 +24,13 @@ use super::event::{
    scancode_to_physicalkey,
 };
 use super::window::WinitWindow;
-use super::DEVICE_ID;
 use crate::dpi::{LogicalPosition, LogicalSize};
 use crate::event::{
-    DeviceEvent, ElementState, Ime, Modifiers, MouseButton, MouseScrollDelta, TouchPhase,
-    WindowEvent,
+    DeviceEvent, ElementState, Ime, Modifiers, MouseButton, MouseScrollDelta, PointerKind,
+    PointerSource, TouchPhase, WindowEvent,
 };
 use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
 use crate::platform::macos::OptionAsAlt;
-use crate::window::WindowId as RootWindowId;

 #[derive(Debug)]
 struct CursorState {
@@ -401,7 +399,7 @@ declare_class!(
                unsafe { &*string }.to_string()
            };

-            let is_control = string.chars().next().map_or(false, |c| c.is_control());
+            let is_control = string.chars().next().is_some_and(|c| c.is_control());

            // Commit only if we have marked text.
            if unsafe { self.hasMarkedText() } && self.is_ime_enabled() && !is_control {
@@ -414,8 +412,9 @@ declare_class!(
        // Basically, we're sent this message whenever a keyboard event that doesn't generate a "human
        // readable" character happens, i.e. newlines, tabs, and Ctrl+C.
        #[method(doCommandBySelector:)]
-        fn do_command_by_selector(&self, _command: Sel) {
+        fn do_command_by_selector(&self, command: Sel) {
            trace_scope!("doCommandBySelector:");
+
            // We shouldn't forward any character from just committed text, since we'll end up sending
            // it twice with some IMEs like Korean one. We'll also always send `Enter` in that case,
            // which is not desired given it was used to confirm IME input.
@@ -430,6 +429,18 @@ declare_class!(
                // Leave preedit so that we also report the key-up for this key.
                self.ivars().ime_state.set(ImeState::Ground);
            }
+
+            // Send command action to user if they requested it.
+            let window_id = self.window().id();
+            self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
+                if let Some(handler) = app.macos_handler() {
+                    handler.standard_key_binding(event_loop, window_id, command.name());
+                }
+            });
+
+            // The documentation for `-[NSTextInputClient doCommandBySelector:]` clearly states that
+            // we should not be forwarding this event up the responder chain, so no calling `super`
+            // here either.
        }
    }

@@ -486,7 +497,7 @@ declare_class!(
            if !had_ime_input || self.ivars().forward_key_to_app.get() {
                let key_event = create_key_event(&event, true, unsafe { event.isARepeat() }, None);
                self.queue_event(WindowEvent::KeyboardInput {
-                    device_id: DEVICE_ID,
+                    device_id: None,
                    event: key_event,
                    is_synthetic: false,
                });
@@ -506,7 +517,7 @@ declare_class!(
                ImeState::Ground | ImeState::Disabled
            ) {
                self.queue_event(WindowEvent::KeyboardInput {
-                    device_id: DEVICE_ID,
+                    device_id: None,
                    event: create_key_event(&event, false, false, None),
                    is_synthetic: false,
                });
@@ -557,7 +568,7 @@ declare_class!(
            let event = create_key_event(&event, true, unsafe { event.isARepeat() }, None);

            self.queue_event(WindowEvent::KeyboardInput {
-                device_id: DEVICE_ID,
+                device_id: None,
                event,
                is_synthetic: false,
            });
@@ -639,19 +650,30 @@ declare_class!(
        }

        #[method(mouseEntered:)]
-        fn mouse_entered(&self, _event: &NSEvent) {
+        fn mouse_entered(&self, event: &NSEvent) {
            trace_scope!("mouseEntered:");
-            self.queue_event(WindowEvent::CursorEntered {
-                device_id: DEVICE_ID,
+
+            let position = self.mouse_view_point(event).to_physical(self.scale_factor());
+
+            self.queue_event(WindowEvent::PointerEntered {
+                device_id: None,
+                primary: true,
+                position,
+                kind: PointerKind::Mouse,
            });
        }

        #[method(mouseExited:)]
-        fn mouse_exited(&self, _event: &NSEvent) {
+        fn mouse_exited(&self, event: &NSEvent) {
            trace_scope!("mouseExited:");

-            self.queue_event(WindowEvent::CursorLeft {
-                device_id: DEVICE_ID,
+            let position = self.mouse_view_point(event).to_physical(self.scale_factor());
+
+            self.queue_event(WindowEvent::PointerLeft {
+                device_id: None,
+                primary: true,
+                position: Some(position),
+                kind: PointerKind::Mouse,
            });
        }

@@ -689,10 +711,10 @@ declare_class!(
            self.update_modifiers(event, false);

            self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop|
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseWheel { delta })
+                app.device_event(event_loop, None, DeviceEvent::MouseWheel { delta })
            );
            self.queue_event(WindowEvent::MouseWheel {
-                device_id: DEVICE_ID,
+                device_id: None,
                delta,
                phase,
            });
@@ -714,7 +736,7 @@ declare_class!(
            };

            self.queue_event(WindowEvent::PinchGesture {
-                device_id: DEVICE_ID,
+                device_id: None,
                delta: unsafe { event.magnification() },
                phase,
            });
@@ -727,7 +749,7 @@ declare_class!(
            self.mouse_motion(event);

            self.queue_event(WindowEvent::DoubleTapGesture {
-                device_id: DEVICE_ID,
+                device_id: None,
            });
        }

@@ -747,7 +769,7 @@ declare_class!(
            };

            self.queue_event(WindowEvent::RotationGesture {
-                device_id: DEVICE_ID,
+                device_id: None,
                delta: unsafe { event.rotation() },
                phase,
            });
@@ -758,7 +780,7 @@ declare_class!(
            trace_scope!("pressureChangeWithEvent:");

            self.queue_event(WindowEvent::TouchpadPressure {
-                device_id: DEVICE_ID,
+                device_id: None,
                pressure: unsafe { event.pressure() },
                stage: unsafe { event.stage() } as i64,
            });
@@ -834,7 +856,7 @@ impl WinitView {
    }

    fn queue_event(&self, event: WindowEvent) {
-        let window_id = RootWindowId(self.window().id());
+        let window_id = self.window().id();
        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
            app.window_event(event_loop, window_id, event);
        });
@@ -972,7 +994,7 @@ impl WinitView {
                        event.location = KeyLocation::Left;
                        event.physical_key = get_left_modifier_code(&event.logical_key).into();
                        events.push_back(WindowEvent::KeyboardInput {
-                            device_id: DEVICE_ID,
+                            device_id: None,
                            event,
                            is_synthetic: false,
                        });
@@ -981,7 +1003,7 @@ impl WinitView {
                        event.location = KeyLocation::Right;
                        event.physical_key = get_right_modifier_code(&event.logical_key).into();
                        events.push_back(WindowEvent::KeyboardInput {
-                            device_id: DEVICE_ID,
+                            device_id: None,
                            event,
                            is_synthetic: false,
                        });
@@ -1012,7 +1034,7 @@ impl WinitView {
                    }

                    events.push_back(WindowEvent::KeyboardInput {
-                        device_id: DEVICE_ID,
+                        device_id: None,
                        event,
                        is_synthetic: false,
                    });
@@ -1034,20 +1056,22 @@ impl WinitView {
    }

    fn mouse_click(&self, event: &NSEvent, button_state: ElementState) {
+        let position = self.mouse_view_point(event).to_physical(self.scale_factor());
        let button = mouse_button(event);

        self.update_modifiers(event, false);

-        self.queue_event(WindowEvent::MouseInput {
-            device_id: DEVICE_ID,
+        self.queue_event(WindowEvent::PointerButton {
+            device_id: None,
+            primary: true,
            state: button_state,
-            button,
+            position,
+            button: button.into(),
        });
    }

    fn mouse_motion(&self, event: &NSEvent) {
-        let window_point = unsafe { event.locationInWindow() };
-        let view_point = self.convertPoint_fromView(window_point, None);
+        let view_point = self.mouse_view_point(event);
        let frame = self.frame();

        if view_point.x.is_sign_negative()
@@ -1062,15 +1086,22 @@ impl WinitView {
            }
        }

-        let view_point = LogicalPosition::new(view_point.x, view_point.y);
-
        self.update_modifiers(event, false);

-        self.queue_event(WindowEvent::CursorMoved {
-            device_id: DEVICE_ID,
+        self.queue_event(WindowEvent::PointerMoved {
+            device_id: None,
+            primary: true,
            position: view_point.to_physical(self.scale_factor()),
+            source: PointerSource::Mouse,
        });
    }
+
+    fn mouse_view_point(&self, event: &NSEvent) -> LogicalPosition<f64> {
+        let window_point = unsafe { event.locationInWindow() };
+        let view_point = self.convertPoint_fromView(window_point, None);
+
+        LogicalPosition::new(view_point.x, view_point.y)
+    }
 }

 /// Get the mouse button from the NSEvent.
--- a/src/platform_impl/apple/appkit/window.rs
+++ b/src/platform_impl/apple/appkit/window.rs
@@ -12,7 +12,7 @@ use crate::error::RequestError;
 use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::window::{
    Cursor, Fullscreen, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow,
-    WindowAttributes, WindowButtons, WindowLevel,
+    WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };

 pub(crate) struct Window {
@@ -42,7 +42,6 @@ impl Window {
        self.delegate.get_on_main(|delegate| f(delegate))
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub(crate) fn raw_window_handle_rwh_06(
        &self,
@@ -54,7 +53,6 @@ impl Window {
        }
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub(crate) fn raw_display_handle_rwh_06(
        &self,
@@ -74,7 +72,6 @@ impl Drop for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_display_handle_rwh_06()?;
@@ -82,7 +79,6 @@ impl rwh_06::HasDisplayHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_window_handle_rwh_06()?;
@@ -92,7 +88,7 @@ impl rwh_06::HasWindowHandle for Window {

 impl CoreWindow for Window {
    fn id(&self) -> crate::window::WindowId {
-        self.maybe_wait_on_main(|delegate| crate::window::WindowId(delegate.id()))
+        self.maybe_wait_on_main(|delegate| delegate.id())
    }

    fn scale_factor(&self) -> f64 {
@@ -111,12 +107,12 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.reset_dead_keys());
    }

-    fn inner_position(&self) -> Result<dpi::PhysicalPosition<i32>, RequestError> {
-        Ok(self.maybe_wait_on_main(|delegate| delegate.inner_position()))
+    fn surface_position(&self) -> dpi::PhysicalPosition<i32> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_position())
    }

    fn outer_position(&self) -> Result<dpi::PhysicalPosition<i32>, RequestError> {
-        Ok(self.maybe_wait_on_main(|delegate| delegate.outer_position()))
+        self.maybe_wait_on_main(|delegate| delegate.outer_position())
    }

    fn set_outer_position(&self, position: Position) {
@@ -135,6 +131,10 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.outer_size())
    }

+    fn safe_area(&self) -> dpi::PhysicalInsets<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.safe_area())
+    }
+
    fn set_min_surface_size(&self, min_size: Option<Size>) {
        self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
    }
@@ -284,8 +284,7 @@ impl CoreWindow for Window {
    }

    fn drag_window(&self) -> Result<(), RequestError> {
-        self.maybe_wait_on_main(|delegate| delegate.drag_window());
-        Ok(())
+        self.maybe_wait_on_main(|delegate| delegate.drag_window())
    }

    fn drag_resize_window(
@@ -324,38 +323,15 @@ impl CoreWindow for Window {
        })
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
 }

-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(pub usize);
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        Self(0)
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0 as u64
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self(raw_id as usize)
-    }
-}
-
 declare_class!(
    #[derive(Debug)]
    pub struct WinitWindow;
@@ -386,6 +362,6 @@ declare_class!(

 impl WinitWindow {
    pub(super) fn id(&self) -> WindowId {
-        WindowId(self as *const Self as usize)
+        WindowId::from_raw(self as *const Self as usize)
    }
 }
--- a/src/platform_impl/apple/appkit/window_delegate.rs
+++ b/src/platform_impl/apple/appkit/window_delegate.rs
@@ -6,7 +6,7 @@ use std::ptr;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};

-use core_graphics::display::{CGDisplay, CGPoint};
+use core_graphics::display::CGDisplay;
 use monitor::VideoModeHandle;
 use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::{AnyObject, ProtocolObject};
@@ -15,15 +15,16 @@ use objc2_app_kit::{
    NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
    NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
    NSColor, NSDraggingDestination, NSFilenamesPboardType, NSPasteboard,
-    NSRequestUserAttentionType, NSScreen, NSView, NSWindowButton, NSWindowDelegate,
+    NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSWindowButton, NSWindowDelegate,
    NSWindowFullScreenButton, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
+    NSWindowToolbarStyle,
 };
 use objc2_foundation::{
-    ns_string, CGFloat, MainThreadMarker, NSArray, NSCopying, NSDictionary, NSKeyValueChangeKey,
-    NSKeyValueChangeNewKey, NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSObject,
-    NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
-    NSRect, NSSize, NSString,
+    ns_string, CGFloat, MainThreadMarker, NSArray, NSCopying, NSDictionary, NSEdgeInsets,
+    NSKeyValueChangeKey, NSKeyValueChangeNewKey, NSKeyValueChangeOldKey,
+    NSKeyValueObservingOptions, NSObject, NSObjectNSDelayedPerforming,
+    NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString,
 };
 use tracing::{trace, warn};

@@ -33,14 +34,17 @@ use super::monitor::{self, flip_window_screen_coordinates, get_display_id};
 use super::observer::RunLoop;
 use super::view::WinitView;
 use super::window::WinitWindow;
-use super::{ffi, Fullscreen, MonitorHandle, WindowId};
-use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use super::{ffi, Fullscreen, MonitorHandle};
+use crate::dpi::{
+    LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
+    Position, Size,
+};
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{SurfaceSizeWriter, WindowEvent};
 use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use crate::window::{
    Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
+    WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };

 #[derive(Clone, Debug, PartialEq)]
@@ -57,6 +61,7 @@ pub struct PlatformSpecificWindowAttributes {
    pub tabbing_identifier: Option<String>,
    pub option_as_alt: OptionAsAlt,
    pub borderless_game: bool,
+    pub unified_titlebar: bool,
 }

 impl Default for PlatformSpecificWindowAttributes {
@@ -75,6 +80,7 @@ impl Default for PlatformSpecificWindowAttributes {
            tabbing_identifier: None,
            option_as_alt: Default::default(),
            borderless_game: false,
+            unified_titlebar: false,
        }
    }
 }
@@ -88,8 +94,8 @@ pub(crate) struct State {

    // During `windowDidResize`, we use this to only send Moved if the position changed.
    //
-    // This is expressed in native screen coordinates.
-    previous_position: Cell<Option<NSPoint>>,
+    // This is expressed in desktop coordinates, and flipped to match Winit's coordinate system.
+    previous_position: Cell<NSPoint>,

    // Used to prevent redundant events.
    previous_scale_factor: Cell<f64>,
@@ -218,10 +224,10 @@ declare_class!(
            trace_scope!("windowDidResignKey:");
            // 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
+            // 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
+            // easily fall out of synchrony with reality. This requires us to emit
            // a synthetic ModifiersChanged event when we lose focus.
            self.view().reset_modifiers();

@@ -439,9 +445,15 @@ declare_class!(
            // NOTE: We don't _really_ need to check the key path, as there should only be one, but
            // in the future we might want to observe other key paths.
            if key_path == Some(ns_string!("effectiveAppearance")) {
-                let change = change.expect("requested a change dictionary in `addObserver`, but none was provided");
-                let old = change.get(unsafe { NSKeyValueChangeOldKey }).expect("requested change dictionary did not contain `NSKeyValueChangeOldKey`");
-                let new = change.get(unsafe { NSKeyValueChangeNewKey }).expect("requested change dictionary did not contain `NSKeyValueChangeNewKey`");
+                let change = change.expect(
+                    "requested a change dictionary in `addObserver`, but none was provided",
+                );
+                let old = change
+                    .get(unsafe { NSKeyValueChangeOldKey })
+                    .expect("requested change dictionary did not contain `NSKeyValueChangeOldKey`");
+                let new = change
+                    .get(unsafe { NSKeyValueChangeNewKey })
+                    .expect("requested change dictionary did not contain `NSKeyValueChangeNewKey`");

                // SAFETY: The value of `effectiveAppearance` is `NSAppearance`
                let old: *const AnyObject = old;
@@ -558,6 +570,12 @@ fn new_window(
        }

        if attrs.platform_specific.fullsize_content_view {
+            // NOTE: If we decide to add an option to change this at runtime, we must emit a
+            // `SurfaceResized` event to let applications know that the safe area changed.
+            //
+            // An alternative would be to add a `WindowEvent::SafeAreaChanged` event, this could be
+            // done with an observer on `safeAreaRect` / `contentLayoutRect`, see:
+            // <https://github.com/rust-windowing/winit/issues/3911>
            masks |= NSWindowStyleMask::FullSizeContentView;
        }

@@ -616,6 +634,14 @@ fn new_window(
        if attrs.platform_specific.movable_by_window_background {
            window.setMovableByWindowBackground(true);
        }
+        if attrs.platform_specific.unified_titlebar {
+            unsafe {
+                // The toolbar style is ignored if there is no toolbar, so it is
+                // necessary to add one.
+                window.setToolbar(Some(&NSToolbar::new(mtm)));
+                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            }
+        }

        if !attrs.enabled_buttons.contains(WindowButtons::MAXIMIZE) {
            if let Some(button) = window.standardWindowButton(NSWindowButton::NSWindowZoomButton) {
@@ -681,7 +707,6 @@ impl WindowDelegate {
        let window = new_window(app_state, &attrs, mtm)
            .ok_or_else(|| os_error!("couldn't create `NSWindow`"))?;

-        #[cfg(feature = "rwh_06")]
        match attrs.parent_window.map(|handle| handle.0) {
            Some(rwh_06::RawWindowHandle::AppKit(handle)) => {
                // SAFETY: Caller ensures the pointer is valid or NULL
@@ -722,7 +747,7 @@ impl WindowDelegate {
        let delegate = mtm.alloc().set_ivars(State {
            app_state: Rc::clone(app_state),
            window: window.retain(),
-            previous_position: Cell::new(None),
+            previous_position: Cell::new(flip_window_screen_coordinates(window.frame())),
            previous_scale_factor: Cell::new(scale_factor),
            surface_resize_increments: Cell::new(surface_resize_increments),
            decorations: Cell::new(attrs.decorations),
@@ -740,12 +765,6 @@ impl WindowDelegate {
        });
        let delegate: Retained<WindowDelegate> = unsafe { msg_send_id![super(delegate), init] };

-        if scale_factor != 1.0 {
-            let delegate = delegate.clone();
-            RunLoop::main(mtm).queue_closure(move || {
-                delegate.handle_scale_factor_changed(scale_factor);
-            });
-        }
        window.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));

        // Listen for theme change event.
@@ -776,10 +795,6 @@ impl WindowDelegate {

        delegate.set_cursor(attrs.cursor);

-        // XXX Send `Focused(false)` right after creating the window delegate, so we won't
-        // obscure the real focused events on the startup.
-        delegate.queue_event(WindowEvent::Focused(false));
-
        // Set fullscreen mode after we setup everything
        delegate.set_fullscreen(attrs.fullscreen.map(Into::into));

@@ -819,7 +834,7 @@ impl WindowDelegate {
    }

    pub(crate) fn queue_event(&self, event: WindowEvent) {
-        let window_id = RootWindowId(self.window().id());
+        let window_id = self.window().id();
        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
            app.window_event(event_loop, window_id, event);
        });
@@ -849,13 +864,12 @@ impl WindowDelegate {
    }

    fn emit_move_event(&self) {
-        let frame = self.window().frame();
-        if self.ivars().previous_position.get() == Some(frame.origin) {
+        let position = flip_window_screen_coordinates(self.window().frame());
+        if self.ivars().previous_position.get() == position {
            return;
        }
-        self.ivars().previous_position.set(Some(frame.origin));
+        self.ivars().previous_position.set(position);

-        let position = flip_window_screen_coordinates(frame);
        let position =
            LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor());
        self.queue_event(WindowEvent::Moved(position));
@@ -925,15 +939,15 @@ impl WindowDelegate {
    #[inline]
    pub fn pre_present_notify(&self) {}

-    pub fn outer_position(&self) -> PhysicalPosition<i32> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
        let position = flip_window_screen_coordinates(self.window().frame());
-        LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor())
+        Ok(LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor()))
    }

-    pub fn inner_position(&self) -> PhysicalPosition<i32> {
+    pub fn surface_position(&self) -> PhysicalPosition<i32> {
        let content_rect = self.window().contentRectForFrameRect(self.window().frame());
-        let position = flip_window_screen_coordinates(content_rect);
-        LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor())
+        let logical = LogicalPosition::new(content_rect.origin.x, content_rect.origin.y);
+        logical.to_physical(self.scale_factor())
    }

    pub fn set_outer_position(&self, position: Position) {
@@ -959,6 +973,32 @@ impl WindowDelegate {
        logical.to_physical(self.scale_factor())
    }

+    pub fn safe_area(&self) -> PhysicalInsets<u32> {
+        // Only available on macOS 11.0
+        let insets = if self.view().respondsToSelector(sel!(safeAreaInsets)) {
+            // Includes NSWindowStyleMask::FullSizeContentView by default, and the notch because
+            // we've set it up with `additionalSafeAreaInsets`.
+            unsafe { self.view().safeAreaInsets() }
+        } else {
+            let content_rect = self.window().contentRectForFrameRect(self.window().frame());
+            // Includes NSWindowStyleMask::FullSizeContentView
+            // Convert from window coordinates to view coordinates
+            let safe_rect = unsafe {
+                self.view().convertRect_fromView(self.window().contentLayoutRect(), None)
+            };
+            NSEdgeInsets {
+                top: safe_rect.origin.y - content_rect.origin.y,
+                left: safe_rect.origin.x - content_rect.origin.x,
+                bottom: (content_rect.size.height + content_rect.origin.x)
+                    - (safe_rect.size.height + safe_rect.origin.x),
+                right: (content_rect.size.width + content_rect.origin.y)
+                    - (safe_rect.size.width + safe_rect.origin.y),
+            }
+        };
+        let insets = LogicalInsets::new(insets.top, insets.left, insets.bottom, insets.right);
+        insets.to_physical(self.scale_factor())
+    }
+
    #[inline]
    pub fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
        let scale_factor = self.scale_factor();
@@ -1155,13 +1195,12 @@ impl WindowDelegate {

    #[inline]
    pub fn set_cursor_position(&self, cursor_position: Position) -> Result<(), RequestError> {
-        let physical_window_position = self.inner_position();
-        let scale_factor = self.scale_factor();
-        let window_position = physical_window_position.to_logical::<CGFloat>(scale_factor);
-        let logical_cursor_position = cursor_position.to_logical::<CGFloat>(scale_factor);
-        let point = CGPoint {
-            x: logical_cursor_position.x + window_position.x,
-            y: logical_cursor_position.y + window_position.y,
+        let content_rect = self.window().contentRectForFrameRect(self.window().frame());
+        let window_position = flip_window_screen_coordinates(content_rect);
+        let cursor_position = cursor_position.to_logical::<CGFloat>(self.scale_factor());
+        let point = core_graphics::display::CGPoint {
+            x: window_position.x + cursor_position.x,
+            y: window_position.y + cursor_position.y,
        };
        CGDisplay::warp_mouse_cursor_position(point)
            .map_err(|status| os_error!(format!("CGError {status}")))?;
@@ -1172,10 +1211,12 @@ impl WindowDelegate {
    }

    #[inline]
-    pub fn drag_window(&self) {
+    pub fn drag_window(&self) -> Result<(), RequestError> {
        let mtm = MainThreadMarker::from(self);
-        let event = NSApplication::sharedApplication(mtm).currentEvent().unwrap();
+        let event =
+            NSApplication::sharedApplication(mtm).currentEvent().ok_or(RequestError::Ignored)?;
        self.window().performWindowDragWithEvent(&event);
+        Ok(())
    }

    #[inline]
@@ -1619,7 +1660,6 @@ impl WindowDelegate {
        Some(monitor)
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
        let window_handle = rwh_06::AppKitWindowHandle::new({
@@ -1742,12 +1782,15 @@ impl WindowExtMacOS for WindowDelegate {
            let screen = self.window().screen().expect("expected screen to be available");
            self.window().setFrame_display(screen.frame(), true);

+            // Configure the safe area rectangle, to ensure that we don't obscure the notch.
+            if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
+                unsafe { self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets()) };
+            }
+
            // Fullscreen windows can't be resized, minimized, or moved
            self.toggle_style_mask(NSWindowStyleMask::Miniaturizable, false);
            self.toggle_style_mask(NSWindowStyleMask::Resizable, false);
            self.window().setMovable(false);
-
-            true
        } else {
            let new_mask = self.saved_style();
            self.set_style_mask(new_mask);
@@ -1760,11 +1803,22 @@ impl WindowExtMacOS for WindowDelegate {
                app.setPresentationOptions(presentation_opts);
            }

+            if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
+                unsafe {
+                    self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
+                        top: 0.0,
+                        left: 0.0,
+                        bottom: 0.0,
+                        right: 0.0,
+                    });
+                }
+            }
+
            self.window().setFrame_display(frame, true);
            self.window().setMovable(true);
-
-            true
        }
+
+        true
    }

    #[inline]
@@ -1836,6 +1890,34 @@ impl WindowExtMacOS for WindowDelegate {
    fn is_borderless_game(&self) -> bool {
        self.ivars().is_borderless_game.get()
    }
+
+    fn set_unified_titlebar(&self, unified_titlebar: bool) {
+        let window = self.window();
+
+        if unified_titlebar {
+            let mtm = MainThreadMarker::from(self);
+
+            unsafe {
+                // The toolbar style is ignored if there is no toolbar, so it is
+                // necessary to add one.
+                window.setToolbar(Some(&NSToolbar::new(mtm)));
+                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            }
+        } else {
+            unsafe {
+                window.setToolbar(None);
+                window.setToolbarStyle(NSWindowToolbarStyle::Automatic);
+            }
+        }
+    }
+
+    fn unified_titlebar(&self) -> bool {
+        let window = self.window();
+
+        unsafe {
+            window.toolbar().is_some() && window.toolbarStyle() == NSWindowToolbarStyle::Unified
+        }
+    }
 }

 const DEFAULT_STANDARD_FRAME: NSRect =
--- a/src/platform_impl/apple/event_handler.rs
+++ b/src/platform_impl/apple/event_handler.rs
@@ -1,33 +1,55 @@
-use std::cell::RefCell;
+use std::cell::Cell;
 use std::{fmt, mem};

 use crate::application::ApplicationHandler;
+use crate::event_loop::ActiveEventLoop;

 /// A helper type for storing a reference to `ApplicationHandler`, allowing interior mutable access
 /// to it within the execution of a closure.
 #[derive(Default)]
 pub(crate) struct EventHandler {
-    /// This can be in the following states:
-    /// - Not registered by the event loop (None).
-    /// - Present (Some(handler)).
-    /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
+    state: Cell<State>,
+}
+
+type InitClosure<'handler> =
+    Box<dyn FnOnce(&dyn ActiveEventLoop) -> Box<dyn ApplicationHandler + 'handler> + 'handler>;
+
+#[derive(Default)]
+enum State {
+    /// Not registered by the event loop.
+    #[default]
+    NotRegistered,
+    /// The event is registered by the event loop.
+    Registered(InitClosure<'static>),
+    /// The application has been initialized, and we're ready to handle events.
+    Ready(Box<dyn ApplicationHandler + 'static>),
+    /// Currently executing the handler.
+    CurrentlyExecuting,
+    /// The application has been terminated.
+    Terminated,
+    // TODO: Invalid state?
 }

 impl fmt::Debug for EventHandler {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = match self.inner.try_borrow().as_deref() {
-            Ok(Some(_)) => "<available>",
-            Ok(None) => "<not set>",
-            Err(_) => "<in use>",
+        let state = self.state.replace(State::CurrentlyExecuting);
+        // NOTE: We're very careful not to panic inside the "critial" section here.
+        let string = match &state {
+            State::NotRegistered => "<not registered>",
+            State::Registered(_) => "<registered>",
+            State::Ready(_) => "<ready>",
+            State::CurrentlyExecuting => "<currently executing>",
+            State::Terminated => "<terminated>",
        };
-        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
+        self.state.set(state);
+
+        f.debug_struct("EventHandler").field("state", &string).finish_non_exhaustive()
    }
 }

 impl EventHandler {
-    pub(crate) fn new() -> Self {
-        Self { inner: RefCell::new(None) }
+    pub(crate) const fn new() -> Self {
+        Self { state: Cell::new(State::NotRegistered) }
    }

    /// Set the event loop handler for the duration of the given closure.
@@ -37,7 +59,7 @@ impl EventHandler {
    /// from within the closure.
    pub(crate) fn set<'handler, R>(
        &self,
-        app: &'handler mut dyn ApplicationHandler,
+        init_closure: InitClosure<'handler>,
        closure: impl FnOnce() -> R,
    ) -> R {
        // SAFETY: We extend the lifetime of the handler here so that we can
@@ -46,14 +68,9 @@ impl EventHandler {
        // This is sound, since we make sure to unset the handler again at the
        // end of this function, and as such the lifetime isn't actually
        // extended beyond `'handler`.
-        let handler = unsafe {
-            mem::transmute::<
-                &'handler mut dyn ApplicationHandler,
-                &'static mut dyn ApplicationHandler,
-            >(app)
-        };
+        let handler = unsafe { mem::transmute::<InitClosure<'handler>, InitClosure<'static>>(app) };

-        match self.inner.try_borrow_mut().as_deref_mut() {
+        match self.state.try_borrow_mut().as_deref_mut() {
            Ok(Some(_)) => {
                unreachable!("tried to set handler while another was already set");
            },
@@ -69,7 +86,7 @@ impl EventHandler {

        impl Drop for ClearOnDrop<'_> {
            fn drop(&mut self) {
-                match self.0.inner.try_borrow_mut().as_deref_mut() {
+                match self.0.state.try_borrow_mut().as_deref_mut() {
                    Ok(data @ Some(_)) => {
                        *data = None;
                    },
@@ -101,6 +118,10 @@ impl EventHandler {
        // soundness.
    }

+    fn init(&self) {}
+
+    fn terminate(&self) {}
+
    #[cfg(target_os = "macos")]
    pub(crate) fn in_use(&self) -> bool {
        self.inner.try_borrow().is_err()
@@ -120,7 +141,7 @@ impl EventHandler {
                //
                // If the handler unwinds, the `RefMut` will ensure that the
                // handler is no longer borrowed.
-                callback(*user_app);
+                callback(user_app);
            },
            Ok(None) => {
                // `NSApplication`, our app state and this handler are all
--- a/src/platform_impl/apple/mod.rs
+++ b/src/platform_impl/apple/mod.rs
@@ -7,7 +7,9 @@ mod notification_center;
 #[cfg(not(target_os = "macos"))]
 mod uikit;

+#[allow(unused_imports)]
 #[cfg(target_os = "macos")]
 pub use self::appkit::*;
+#[allow(unused_imports)]
 #[cfg(not(target_os = "macos"))]
 pub use self::uikit::*;
--- a/src/platform_impl/apple/uikit/app_state.rs
+++ b/src/platform_impl/apple/uikit/app_state.rs
@@ -3,7 +3,7 @@
 use std::cell::{OnceCell, RefCell, RefMut};
 use std::collections::HashSet;
 use std::os::raw::c_void;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex, OnceLock};
 use std::time::Instant;
 use std::{mem, ptr};
@@ -24,12 +24,11 @@ use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView, UIWindow};

 use super::super::event_handler::EventHandler;
 use super::window::WinitUIWindow;
-use super::ActiveEventLoop;
+use super::{ActiveEventLoop, EventLoopProxy};
 use crate::application::ApplicationHandler;
 use crate::dpi::PhysicalSize;
 use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::ControlFlow;
-use crate::window::WindowId as RootWindowId;

 macro_rules! bug {
    ($($msg:tt)*) => {
@@ -140,7 +139,7 @@ pub(crate) struct AppState {
    app_state: Option<AppStateImpl>,
    control_flow: ControlFlow,
    waker: EventLoopWaker,
-    proxy_wake_up: Arc<AtomicBool>,
+    event_loop_proxy: Arc<EventLoopProxy>,
 }

 impl AppState {
@@ -150,6 +149,8 @@ impl AppState {
        // must be mut because plain `static` requires `Sync`
        static mut APP_STATE: RefCell<Option<AppState>> = RefCell::new(None);

+        #[allow(unknown_lints)] // New lint below
+        #[allow(static_mut_refs)] // TODO: Use `MainThreadBound` instead.
        let mut guard = unsafe { APP_STATE.borrow_mut() };
        if guard.is_none() {
            #[inline(never)]
@@ -163,7 +164,7 @@ impl AppState {
                    }),
                    control_flow: ControlFlow::default(),
                    waker,
-                    proxy_wake_up: Arc::new(AtomicBool::new(false)),
+                    event_loop_proxy: Arc::new(EventLoopProxy::new()),
                });
            }
            init_guard(&mut guard);
@@ -375,8 +376,8 @@ impl AppState {
        }
    }

-    pub(crate) fn proxy_wake_up(&self) -> Arc<AtomicBool> {
-        self.proxy_wake_up.clone()
+    pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
+        &self.event_loop_proxy
    }

    pub(crate) fn set_control_flow(&mut self, control_flow: ControlFlow) {
@@ -542,10 +543,10 @@ fn handle_user_events(mtm: MainThreadMarker) {
    if processing_redraws {
        bug!("user events attempted to be sent out while `ProcessingRedraws`");
    }
-    let proxy_wake_up = this.proxy_wake_up.clone();
+    let event_loop_proxy = this.event_loop_proxy().clone();
    drop(this);

-    if proxy_wake_up.swap(false, Ordering::Relaxed) {
+    if event_loop_proxy.wake_up.swap(false, Ordering::Relaxed) {
        handle_event(mtm, Event::UserWakeUp);
    }

@@ -577,7 +578,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
            }
        }

-        if proxy_wake_up.swap(false, Ordering::Relaxed) {
+        if event_loop_proxy.wake_up.swap(false, Ordering::Relaxed) {
            handle_event(mtm, Event::UserWakeUp);
        }
    }
@@ -597,7 +598,7 @@ pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, o
                &*ptr
            };
            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::Occluded(occluded),
            }));
        }
@@ -624,7 +625,7 @@ pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
        .into_iter()
        .map(|window| {
            EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::RedrawRequested,
            })
        })
@@ -653,7 +654,7 @@ pub(crate) fn terminated(application: &UIApplication) {
                &*ptr
            };
            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::Destroyed,
            }));
        }
@@ -671,7 +672,7 @@ fn handle_hidpi_proxy(mtm: MainThreadMarker, event: ScaleFactorChanged) {
    let ScaleFactorChanged { suggested_size, scale_factor, window } = event;
    let new_surface_size = Arc::new(Mutex::new(suggested_size));
    let event = Event::WindowEvent {
-        window_id: RootWindowId(window.id()),
+        window_id: window.id(),
        event: WindowEvent::ScaleFactorChanged {
            scale_factor,
            surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
--- a/src/platform_impl/apple/uikit/event_loop.rs
+++ b/src/platform_impl/apple/uikit/event_loop.rs
@@ -20,6 +20,7 @@ use objc2_ui_kit::{
    UIApplicationWillEnterForegroundNotification, UIApplicationWillResignActiveNotification,
    UIApplicationWillTerminateNotification, UIScreen,
 };
+use rwh_06::HasDisplayHandle;

 use super::super::notification_center::create_observer;
 use super::app_state::{send_occluded_event_for_all_windows, AppState, EventWrapper};
@@ -29,7 +30,8 @@ use crate::error::{EventLoopError, NotSupportedError, RequestError};
 use crate::event::Event;
 use crate::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform_impl::Window;
@@ -41,9 +43,8 @@ pub(crate) struct ActiveEventLoop {
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> crate::event_loop::EventLoopProxy {
-        let event_loop_proxy = EventLoopProxy::new(AppState::get_mut(self.mtm).proxy_wake_up());
-        RootEventLoopProxy { event_loop_proxy }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        CoreEventLoopProxy::new(AppState::get_mut(self.mtm).event_loop_proxy().clone())
    }

    fn create_window(
@@ -94,17 +95,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
        false
    }

-    fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
-        RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(Arc::new(OwnedDisplayHandle))
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new());
@@ -115,13 +114,10 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
 #[derive(Clone, PartialEq, Eq)]
 pub(crate) struct OwnedDisplayHandle;

-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::UiKitDisplayHandle::new().into())
+impl HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new());
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
    }
 }

@@ -292,19 +288,13 @@ impl EventLoop {
 }

 pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
+    pub(crate) wake_up: AtomicBool,
    source: CFRunLoopSourceRef,
 }

 unsafe impl Send for EventLoopProxy {}
 unsafe impl Sync for EventLoopProxy {}

-impl Clone for EventLoopProxy {
-    fn clone(&self) -> EventLoopProxy {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
-    }
-}
-
 impl Drop for EventLoopProxy {
    fn drop(&mut self) {
        unsafe {
@@ -315,7 +305,7 @@ impl Drop for EventLoopProxy {
 }

 impl EventLoopProxy {
-    fn new(proxy_wake_up: Arc<AtomicBool>) -> EventLoopProxy {
+    pub(crate) fn new() -> EventLoopProxy {
        unsafe {
            // just wake up the eventloop
            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -339,12 +329,14 @@ impl EventLoopProxy {
            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
            CFRunLoopWakeUp(rl);

-            EventLoopProxy { proxy_wake_up, source }
+            EventLoopProxy { wake_up: AtomicBool::new(false), source }
        }
    }
+}

-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.wake_up.store(true, AtomicOrdering::Relaxed);
        unsafe {
            // let the main thread know there's a new event
            CFRunLoopSourceSignal(self.source);
--- a/src/platform_impl/apple/uikit/mod.rs
+++ b/src/platform_impl/apple/uikit/mod.rs
@@ -10,42 +10,16 @@ mod window;
 use std::fmt;

 pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
-    PlatformSpecificEventLoopAttributes,
+    ActiveEventLoop, EventLoop, EventLoopProxy, PlatformSpecificEventLoopAttributes,
 };
 pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
-pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
+pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window};
 pub(crate) use crate::cursor::{
    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
 };
-use crate::event::DeviceId as RootDeviceId;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;

-/// There is no way to detect which device that performed a certain event in
-/// UIKit (i.e. you can't differentiate between different external keyboards,
-/// or whether it was the main touchscreen, assistive technologies, or some
-/// other pointer device that caused a touch event).
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId;
-
-impl DeviceId {
-    pub const fn dummy() -> Self {
-        DeviceId
-    }
-}
-
-pub(crate) const DEVICE_ID: RootDeviceId = RootDeviceId(DeviceId);
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId(usize);
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId(0)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct KeyEventExtra {}

--- a/src/platform_impl/apple/uikit/view.rs
+++ b/src/platform_impl/apple/uikit/view.rs
@@ -6,22 +6,23 @@ use objc2::runtime::{NSObjectProtocol, ProtocolObject};
 use objc2::{declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass};
 use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet, NSString};
 use objc2_ui_kit::{
-    UICoordinateSpace, UIEvent, UIForceTouchCapability, UIGestureRecognizer,
-    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIKeyInput, UIPanGestureRecognizer,
-    UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer,
-    UITextInputTraits, UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
+    UIEvent, UIForceTouchCapability, UIGestureRecognizer, UIGestureRecognizerDelegate,
+    UIGestureRecognizerState, UIKeyInput, UIPanGestureRecognizer, UIPinchGestureRecognizer,
+    UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer, UITextInputTraits, UITouch,
+    UITouchPhase, UITouchType, UITraitEnvironment, UIView,
 };
+use tracing::debug;

 use super::app_state::{self, EventWrapper};
 use super::window::WinitUIWindow;
-use super::{FingerId, DEVICE_ID};
 use crate::dpi::PhysicalPosition;
 use crate::event::{
-    ElementState, Event, FingerId as RootFingerId, Force, KeyEvent, Touch, TouchPhase, WindowEvent,
+    ButtonSource, ElementState, Event, FingerId, Force, KeyEvent, PointerKind, PointerSource,
+    TouchPhase, WindowEvent,
 };
 use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey};
 use crate::platform_impl::KeyEventExtra;
-use crate::window::{WindowAttributes, WindowId as RootWindowId};
+use crate::window::WindowAttributes;

 pub struct WinitViewState {
    pinch_gesture_recognizer: RefCell<Option<Retained<UIPinchGestureRecognizer>>>,
@@ -33,6 +34,9 @@ pub struct WinitViewState {
    rotation_last_delta: Cell<CGFloat>,
    pinch_last_delta: Cell<CGFloat>,
    pan_last_delta: Cell<CGPoint>,
+
+    primary_finger: Cell<Option<FingerId>>,
+    fingers: Cell<u8>,
 }

 declare_class!(
@@ -57,7 +61,7 @@ declare_class!(
            app_state::handle_nonuser_event(
                mtm,
                EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
+                    window_id: window.id(),
                    event: WindowEvent::RedrawRequested,
                }),
            );
@@ -69,30 +73,19 @@ declare_class!(
            let mtm = MainThreadMarker::new().unwrap();
            let _: () = unsafe { msg_send![super(self), layoutSubviews] };

-            let window = self.window().unwrap();
-            let window_bounds = window.bounds();
-            let screen = window.screen();
-            let screen_space = screen.coordinateSpace();
-            let screen_frame = self.convertRect_toCoordinateSpace(window_bounds, &screen_space);
-            let scale_factor = screen.scale();
+            let frame = self.frame();
+            let scale_factor = self.contentScaleFactor() as f64;
            let size = crate::dpi::LogicalSize {
-                width: screen_frame.size.width as f64,
-                height: screen_frame.size.height as f64,
-            }
-            .to_physical(scale_factor as f64);
-
-            // If the app is started in landscape, the view frame and window bounds can be mismatched.
-            // The view frame will be in portrait and the window bounds in landscape. So apply the
-            // window bounds to the view frame to make it consistent.
-            let view_frame = self.frame();
-            if view_frame != window_bounds {
-                self.setFrame(window_bounds);
+                width: frame.size.width as f64,
+                height: frame.size.height as f64,
            }
+            .to_physical(scale_factor);

+            let window = self.window().unwrap();
            app_state::handle_nonuser_event(
                mtm,
                EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
+                    window_id: window.id(),
                    event: WindowEvent::SurfaceResized(size),
                }),
            );
@@ -123,15 +116,12 @@ declare_class!(
                "invalid scale_factor set on UIView",
            );
            let scale_factor = scale_factor as f64;
-            let bounds = self.bounds();
-            let screen = window.screen();
-            let screen_space = screen.coordinateSpace();
-            let screen_frame = self.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let frame = self.frame();
            let size = crate::dpi::LogicalSize {
-                width: screen_frame.size.width as f64,
-                height: screen_frame.size.height as f64,
+                width: frame.size.width as f64,
+                height: frame.size.height as f64,
            };
-            let window_id = RootWindowId(window.id());
+            let window_id = window.id();
            app_state::handle_nonuser_events(
                mtm,
                std::iter::once(EventWrapper::ScaleFactorChanged(
@@ -150,6 +140,13 @@ declare_class!(
            );
        }

+        #[method(safeAreaInsetsDidChange)]
+        fn safe_area_changed(&self) {
+            debug!("safeAreaInsetsDidChange was called, requesting redraw");
+            // When the safe area changes we want to make sure to emit a redraw event
+            self.setNeedsDisplay();
+        }
+
        #[method(touchesBegan:withEvent:)]
        fn touches_began(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
            self.handle_touches(touches)
@@ -192,13 +189,13 @@ declare_class!(
                    // Pass -delta so that action is reversed
                    (TouchPhase::Cancelled, -recognizer.scale())
                }
-                state => panic!("unexpected recognizer state: {:?}", state),
+                state => panic!("unexpected recognizer state: {state:?}"),
            };

            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::PinchGesture {
-                    device_id: DEVICE_ID,
+                    device_id: None,
                    delta: delta as f64,
                    phase,
                },
@@ -214,9 +211,9 @@ declare_class!(

            if recognizer.state() == UIGestureRecognizerState::Ended {
                let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
+                    window_id: window.id(),
                    event: WindowEvent::DoubleTapGesture {
-                        device_id: DEVICE_ID,
+                        device_id: None,
                    },
                });

@@ -251,14 +248,14 @@ declare_class!(
                    // Pass -delta so that action is reversed
                    (TouchPhase::Cancelled, -recognizer.rotation())
                }
-                state => panic!("unexpected recognizer state: {:?}", state),
+                state => panic!("unexpected recognizer state: {state:?}"),
            };

            // Make delta negative to match macos, convert to degrees
            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::RotationGesture {
-                    device_id: DEVICE_ID,
+                    device_id: None,
                    delta: -delta.to_degrees() as _,
                    phase,
                },
@@ -302,14 +299,14 @@ declare_class!(
                    // Pass -delta so that action is reversed
                    (TouchPhase::Cancelled, -last_pan.x, -last_pan.y)
                }
-                state => panic!("unexpected recognizer state: {:?}", state),
+                state => panic!("unexpected recognizer state: {state:?}"),
            };


            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
+                window_id: window.id(),
                event: WindowEvent::PanGesture {
-                    device_id: DEVICE_ID,
+                    device_id: None,
                    delta: PhysicalPosition::new(dx as _, dy as _),
                    phase,
                },
@@ -370,6 +367,9 @@ impl WinitView {
            rotation_last_delta: Cell::new(0.0),
            pinch_last_delta: Cell::new(0.0),
            pan_last_delta: Cell::new(CGPoint { x: 0.0, y: 0.0 }),
+
+            primary_finger: Cell::new(None),
+            fingers: Cell::new(0),
        });
        let this: Retained<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };

@@ -483,25 +483,18 @@ impl WinitView {
        for touch in touches {
            let logical_location = touch.locationInView(None);
            let touch_type = touch.r#type();
-            let force = if os_supports_force {
+            let force = if let UITouchType::Pencil = touch_type {
+                None
+            } else if os_supports_force {
                let trait_collection = self.traitCollection();
                let touch_capability = trait_collection.forceTouchCapability();
                // Both the OS _and_ the device need to be checked for force touch support.
-                if touch_capability == UIForceTouchCapability::Available
-                    || touch_type == UITouchType::Pencil
-                {
+                if touch_capability == UIForceTouchCapability::Available {
                    let force = touch.force();
                    let max_possible_force = touch.maximumPossibleForce();
-                    let altitude_angle: Option<f64> = if touch_type == UITouchType::Pencil {
-                        let angle = touch.altitudeAngle();
-                        Some(angle as _)
-                    } else {
-                        None
-                    };
                    Some(Force::Calibrated {
                        force: force as _,
                        max_possible_force: max_possible_force as _,
-                        altitude_angle,
                    })
                } else {
                    None
@@ -511,32 +504,134 @@ impl WinitView {
            };
            let touch_id = touch as *const UITouch as usize;
            let phase = touch.phase();
-            let phase = match phase {
-                UITouchPhase::Began => TouchPhase::Started,
-                UITouchPhase::Moved => TouchPhase::Moved,
-                // 2 is UITouchPhase::Stationary and is not expected here
-                UITouchPhase::Ended => TouchPhase::Ended,
-                UITouchPhase::Cancelled => TouchPhase::Cancelled,
-                _ => panic!("unexpected touch phase: {phase:?}"),
-            };
-
-            let physical_location = {
+            let position = {
                let scale_factor = self.contentScaleFactor();
                PhysicalPosition::from_logical::<(f64, f64), f64>(
                    (logical_location.x as _, logical_location.y as _),
                    scale_factor as f64,
                )
            };
-            touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
-                event: WindowEvent::Touch(Touch {
-                    device_id: DEVICE_ID,
-                    finger_id: RootFingerId(FingerId(touch_id)),
-                    location: physical_location,
-                    force,
-                    phase,
-                }),
-            }));
+            let window_id = window.id();
+            let finger_id = FingerId::from_raw(touch_id);
+
+            let ivars = self.ivars();
+
+            match phase {
+                UITouchPhase::Began => {
+                    let primary = if let UITouchType::Pencil = touch_type {
+                        true
+                    } else {
+                        ivars.fingers.set(ivars.fingers.get() + 1);
+                        // Keep the primary finger around until we clear all the fingers to
+                        // recognize it when user briefly removes it.
+                        match ivars.primary_finger.get() {
+                            Some(primary_id) => primary_id == finger_id,
+                            None => {
+                                debug_assert_eq!(
+                                    ivars.fingers.get(),
+                                    1,
+                                    "number of fingers were not counted correctly"
+                                );
+                                ivars.primary_finger.set(Some(finger_id));
+                                true
+                            },
+                        }
+                    };
+
+                    touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerEntered {
+                            device_id: None,
+                            primary,
+                            position,
+                            kind: if let UITouchType::Pencil = touch_type {
+                                PointerKind::Unknown
+                            } else {
+                                PointerKind::Touch(finger_id)
+                            },
+                        },
+                    }));
+                    touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerButton {
+                            device_id: None,
+                            primary,
+                            state: ElementState::Pressed,
+                            position,
+                            button: if let UITouchType::Pencil = touch_type {
+                                ButtonSource::Unknown(0)
+                            } else {
+                                ButtonSource::Touch { finger_id, force }
+                            },
+                        },
+                    }));
+                },
+                UITouchPhase::Moved => {
+                    let (primary, source) = if let UITouchType::Pencil = touch_type {
+                        (true, PointerSource::Unknown)
+                    } else {
+                        (ivars.primary_finger.get().unwrap() == finger_id, PointerSource::Touch {
+                            finger_id,
+                            force,
+                        })
+                    };
+
+                    touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerMoved {
+                            device_id: None,
+                            primary,
+                            position,
+                            source,
+                        },
+                    }));
+                },
+                // 2 is UITouchPhase::Stationary and is not expected here
+                UITouchPhase::Ended | UITouchPhase::Cancelled => {
+                    let primary = if let UITouchType::Pencil = touch_type {
+                        true
+                    } else {
+                        ivars.fingers.set(ivars.fingers.get() - 1);
+                        let primary = ivars.primary_finger.get().unwrap() == finger_id;
+                        if ivars.fingers.get() == 0 {
+                            ivars.primary_finger.set(None);
+                        }
+                        primary
+                    };
+
+                    if let UITouchPhase::Ended = phase {
+                        touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                            window_id,
+                            event: WindowEvent::PointerButton {
+                                device_id: None,
+                                primary,
+                                state: ElementState::Released,
+                                position,
+                                button: if let UITouchType::Pencil = touch_type {
+                                    ButtonSource::Unknown(0)
+                                } else {
+                                    ButtonSource::Touch { finger_id, force }
+                                },
+                            },
+                        }));
+                    }
+
+                    touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerLeft {
+                            device_id: None,
+                            primary,
+                            position: Some(position),
+                            kind: if let UITouchType::Pencil = touch_type {
+                                PointerKind::Unknown
+                            } else {
+                                PointerKind::Touch(finger_id)
+                            },
+                        },
+                    }));
+                },
+                _ => panic!("unexpected touch phase: {phase:?}"),
+            }
        }
        let mtm = MainThreadMarker::new().unwrap();
        app_state::handle_nonuser_events(mtm, touch_events);
@@ -544,7 +639,7 @@ impl WinitView {

    fn handle_insert_text(&self, text: &NSString) {
        let window = self.window().unwrap();
-        let window_id = RootWindowId(window.id());
+        let window_id = window.id();
        let mtm = MainThreadMarker::new().unwrap();
        // send individual events for each character
        app_state::handle_nonuser_events(
@@ -572,7 +667,7 @@ impl WinitView {
                                platform_specific: KeyEventExtra {},
                            },
                            is_synthetic: false,
-                            device_id: DEVICE_ID,
+                            device_id: None,
                        },
                    })
                })
@@ -582,7 +677,7 @@ impl WinitView {

    fn handle_delete_backward(&self) {
        let window = self.window().unwrap();
-        let window_id = RootWindowId(window.id());
+        let window_id = window.id();
        let mtm = MainThreadMarker::new().unwrap();
        app_state::handle_nonuser_events(
            mtm,
@@ -590,7 +685,7 @@ impl WinitView {
                EventWrapper::StaticEvent(Event::WindowEvent {
                    window_id,
                    event: WindowEvent::KeyboardInput {
-                        device_id: DEVICE_ID,
+                        device_id: None,
                        event: KeyEvent {
                            state,
                            logical_key: Key::Named(NamedKey::Backspace),
--- a/src/platform_impl/apple/uikit/window.rs
+++ b/src/platform_impl/apple/uikit/window.rs
@@ -3,14 +3,13 @@
 use std::collections::VecDeque;

 use objc2::rc::Retained;
-use objc2::runtime::{AnyObject, NSObject};
 use objc2::{class, declare_class, msg_send, msg_send_id, mutability, ClassType, DeclaredClass};
 use objc2_foundation::{
-    CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker, NSObjectProtocol,
+    CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker, NSObject, NSObjectProtocol,
 };
 use objc2_ui_kit::{
-    UIApplication, UICoordinateSpace, UIResponder, UIScreen, UIScreenOverscanCompensation,
-    UIViewController, UIWindow,
+    UIApplication, UICoordinateSpace, UIEdgeInsets, UIResponder, UIScreen,
+    UIScreenOverscanCompensation, UIViewController, UIWindow,
 };
 use tracing::{debug, warn};

@@ -19,7 +18,10 @@ use super::view::WinitView;
 use super::view_controller::WinitViewController;
 use super::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle};
 use crate::cursor::Cursor;
-use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{
+    LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
+    Position, Size,
+};
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Event, WindowEvent};
 use crate::icon::Icon;
@@ -27,7 +29,7 @@ use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
 use crate::window::{
    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
-    WindowAttributes, WindowButtons, WindowId as CoreWindowId, WindowLevel,
+    WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };

 declare_class!(
@@ -50,7 +52,7 @@ declare_class!(
            app_state::handle_nonuser_event(
                mtm,
                EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: CoreWindowId(self.id()),
+                    window_id: self.id(),
                    event: WindowEvent::Focused(true),
                }),
            );
@@ -63,7 +65,7 @@ declare_class!(
            app_state::handle_nonuser_event(
                mtm,
                EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: CoreWindowId(self.id()),
+                    window_id: self.id(),
                    event: WindowEvent::Focused(false),
                }),
            );
@@ -106,7 +108,7 @@ impl WinitUIWindow {
    }

    pub(crate) fn id(&self) -> WindowId {
-        (self as *const Self as usize as u64).into()
+        WindowId::from_raw(self as *const Self as usize)
    }
 }

@@ -159,20 +161,19 @@ impl Inner {

    pub fn pre_present_notify(&self) {}

-    pub fn inner_position(&self) -> PhysicalPosition<i32> {
-        let safe_area = self.safe_area_screen_space();
+    pub fn surface_position(&self) -> PhysicalPosition<i32> {
+        let view_position = self.view.frame().origin;
        let position =
-            LogicalPosition { x: safe_area.origin.x as f64, y: safe_area.origin.y as f64 };
-        let scale_factor = self.scale_factor();
-        position.to_physical(scale_factor)
+            unsafe { self.window.convertPoint_fromView(view_position, Some(&self.view)) };
+        let position = LogicalPosition::new(position.x, position.y);
+        position.to_physical(self.scale_factor())
    }

-    pub fn outer_position(&self) -> PhysicalPosition<i32> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
        let screen_frame = self.screen_frame();
        let position =
            LogicalPosition { x: screen_frame.origin.x as f64, y: screen_frame.origin.y as f64 };
-        let scale_factor = self.scale_factor();
-        position.to_physical(scale_factor)
+        Ok(position.to_physical(self.scale_factor()))
    }

    pub fn set_outer_position(&self, physical_position: Position) {
@@ -188,29 +189,36 @@ impl Inner {
    }

    pub fn surface_size(&self) -> PhysicalSize<u32> {
-        let scale_factor = self.scale_factor();
-        let safe_area = self.safe_area_screen_space();
-        let size = LogicalSize {
-            width: safe_area.size.width as f64,
-            height: safe_area.size.height as f64,
-        };
-        size.to_physical(scale_factor)
+        let frame = self.view.frame();
+        let size = LogicalSize::new(frame.size.width, frame.size.height);
+        size.to_physical(self.scale_factor())
    }

    pub fn outer_size(&self) -> PhysicalSize<u32> {
-        let scale_factor = self.scale_factor();
-        let screen_frame = self.screen_frame();
-        let size = LogicalSize {
-            width: screen_frame.size.width as f64,
-            height: screen_frame.size.height as f64,
-        };
-        size.to_physical(scale_factor)
+        let frame = self.window.frame();
+        let size = LogicalSize::new(frame.size.width, frame.size.height);
+        size.to_physical(self.scale_factor())
    }

    pub fn request_surface_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
        Some(self.surface_size())
    }

+    pub fn safe_area(&self) -> PhysicalInsets<u32> {
+        // Only available on iOS 11.0
+        let insets = if app_state::os_capabilities().safe_area {
+            self.view.safeAreaInsets()
+        } else {
+            // Assume the status bar frame is the only thing that obscures the view
+            let app = UIApplication::sharedApplication(MainThreadMarker::new().unwrap());
+            #[allow(deprecated)]
+            let status_bar_frame = app.statusBarFrame();
+            UIEdgeInsets { top: status_bar_frame.size.height, left: 0.0, bottom: 0.0, right: 0.0 }
+        };
+        let insets = LogicalInsets::new(insets.top, insets.left, insets.bottom, insets.right);
+        insets.to_physical(self.scale_factor())
+    }
+
    pub fn set_min_surface_size(&self, _dimensions: Option<Size>) {
        warn!("`Window::set_min_surface_size` is ignored on iOS")
    }
@@ -421,7 +429,6 @@ impl Inner {
        self.window.id()
    }

-    #[cfg(feature = "rwh_06")]
    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
        let mut window_handle = rwh_06::UiKitWindowHandle::new({
            let ui_view = Retained::as_ptr(&self.view) as _;
@@ -510,36 +517,6 @@ impl Window {
        let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
        window.makeKeyAndVisible();

-        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `SurfaceResized`
-        // event on window creation if the DPI factor != 1.0
-        let scale_factor = view.contentScaleFactor();
-        let scale_factor = scale_factor as f64;
-        if scale_factor != 1.0 {
-            let bounds = view.bounds();
-            let screen = window.screen();
-            let screen_space = screen.coordinateSpace();
-            let screen_frame = view.convertRect_toCoordinateSpace(bounds, &screen_space);
-            let size = LogicalSize {
-                width: screen_frame.size.width as f64,
-                height: screen_frame.size.height as f64,
-            };
-            let window_id = CoreWindowId(window.id());
-            app_state::handle_nonuser_events(
-                mtm,
-                std::iter::once(EventWrapper::ScaleFactorChanged(app_state::ScaleFactorChanged {
-                    window: window.clone(),
-                    scale_factor,
-                    suggested_size: size.to_physical(scale_factor),
-                }))
-                .chain(std::iter::once(EventWrapper::StaticEvent(
-                    Event::WindowEvent {
-                        window_id,
-                        event: WindowEvent::SurfaceResized(size.to_physical(scale_factor)),
-                    },
-                ))),
-            );
-        }
-
        let inner = Inner { window, view_controller, view, gl_or_metal_backed };
        Ok(Window { inner: MainThreadBound::new(inner, mtm) })
    }
@@ -548,7 +525,6 @@ impl Window {
        self.inner.get_on_main(|inner| f(inner))
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub(crate) fn raw_window_handle_rwh_06(
        &self,
@@ -560,7 +536,6 @@ impl Window {
        }
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub(crate) fn raw_display_handle_rwh_06(
        &self,
@@ -569,7 +544,6 @@ impl Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_display_handle_rwh_06()?;
@@ -577,7 +551,6 @@ impl rwh_06::HasDisplayHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_window_handle_rwh_06()?;
@@ -587,7 +560,7 @@ impl rwh_06::HasWindowHandle for Window {

 impl CoreWindow for Window {
    fn id(&self) -> crate::window::WindowId {
-        self.maybe_wait_on_main(|delegate| crate::window::WindowId(delegate.id()))
+        self.maybe_wait_on_main(|delegate| delegate.id())
    }

    fn scale_factor(&self) -> f64 {
@@ -606,12 +579,12 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.reset_dead_keys());
    }

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        Ok(self.maybe_wait_on_main(|delegate| delegate.inner_position()))
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_position())
    }

    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        Ok(self.maybe_wait_on_main(|delegate| delegate.outer_position()))
+        self.maybe_wait_on_main(|delegate| delegate.outer_position())
    }

    fn set_outer_position(&self, position: Position) {
@@ -630,6 +603,10 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.outer_size())
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.safe_area())
+    }
+
    fn set_min_surface_size(&self, min_size: Option<Size>) {
        self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
    }
@@ -817,12 +794,10 @@ impl CoreWindow for Window {
        })
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
@@ -890,7 +865,7 @@ impl Inner {

 impl Inner {
    fn screen_frame(&self) -> CGRect {
-        self.rect_to_screen_space(self.window.bounds())
+        self.rect_to_screen_space(self.window.frame())
    }

    fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
@@ -902,75 +877,6 @@ impl Inner {
        let screen_space = self.window.screen().coordinateSpace();
        self.window.convertRect_fromCoordinateSpace(rect, &screen_space)
    }
-
-    fn safe_area_screen_space(&self) -> CGRect {
-        let bounds = self.window.bounds();
-        if app_state::os_capabilities().safe_area {
-            let safe_area = self.window.safeAreaInsets();
-            let safe_bounds = CGRect {
-                origin: CGPoint {
-                    x: bounds.origin.x + safe_area.left,
-                    y: bounds.origin.y + safe_area.top,
-                },
-                size: CGSize {
-                    width: bounds.size.width - safe_area.left - safe_area.right,
-                    height: bounds.size.height - safe_area.top - safe_area.bottom,
-                },
-            };
-            self.rect_to_screen_space(safe_bounds)
-        } else {
-            let screen_frame = self.rect_to_screen_space(bounds);
-            let status_bar_frame = {
-                let app = UIApplication::sharedApplication(MainThreadMarker::new().unwrap());
-                #[allow(deprecated)]
-                app.statusBarFrame()
-            };
-            let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
-                (screen_frame.origin.y, screen_frame.size.height)
-            } else {
-                let y = status_bar_frame.size.height;
-                let height = screen_frame.size.height
-                    - (status_bar_frame.size.height - screen_frame.origin.y);
-                (y, height)
-            };
-            CGRect {
-                origin: CGPoint { x: screen_frame.origin.x, y },
-                size: CGSize { width: screen_frame.size.width, height },
-            }
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId {
-    window: *mut WinitUIWindow,
-}
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        WindowId { window: std::ptr::null_mut() }
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.window as u64
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self { window: raw_id as _ }
-    }
-}
-
-unsafe impl Send for WindowId {}
-unsafe impl Sync for WindowId {}
-
-impl From<&AnyObject> for WindowId {
-    fn from(window: &AnyObject) -> WindowId {
-        WindowId { window: window as *const _ as _ }
-    }
 }

 #[derive(Clone, Debug, Default, PartialEq)]
--- a/src/platform_impl/linux/common/xkb/keymap.rs
+++ b/src/platform_impl/linux/common/xkb/keymap.rs
@@ -35,6 +35,9 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
    // are defined by the Linux kernel. If Winit programs end up being run on other Unix-likes,
    // I can only hope they agree on what the keycodes mean.
    //
+    // The mapping here is heavily influenced by Firefox' source:
+    // https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
+    //
    // Some of the keycodes are likely superfluous for our purposes, and some are ones which are
    // difficult to test the correctness of, or discover the purpose of. Because of this, they've
    // either been commented out here, or not included at all.
@@ -166,23 +169,23 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        125 => KeyCode::SuperLeft,
        126 => KeyCode::SuperRight,
        127 => KeyCode::ContextMenu,
-        // 128 => KeyCode::STOP,
-        // 129 => KeyCode::AGAIN,
-        // 130 => KeyCode::PROPS,
-        // 131 => KeyCode::UNDO,
-        // 132 => KeyCode::FRONT,
-        // 133 => KeyCode::COPY,
-        // 134 => KeyCode::OPEN,
-        // 135 => KeyCode::PASTE,
-        // 136 => KeyCode::FIND,
-        // 137 => KeyCode::CUT,
-        // 138 => KeyCode::HELP,
+        128 => KeyCode::BrowserStop,
+        129 => KeyCode::Again,
+        130 => KeyCode::Props,
+        131 => KeyCode::Undo,
+        132 => KeyCode::Select, // FRONT
+        133 => KeyCode::Copy,
+        134 => KeyCode::Open,
+        135 => KeyCode::Paste,
+        136 => KeyCode::Find,
+        137 => KeyCode::Cut,
+        138 => KeyCode::Help,
        // 139 => KeyCode::MENU,
-        // 140 => KeyCode::CALC,
+        140 => KeyCode::LaunchApp2, // CALC
        // 141 => KeyCode::SETUP,
        // 142 => KeyCode::SLEEP,
-        // 143 => KeyCode::WAKEUP,
-        // 144 => KeyCode::FILE,
+        143 => KeyCode::WakeUp,
+        144 => KeyCode::LaunchApp1, // FILE
        // 145 => KeyCode::SENDFILE,
        // 146 => KeyCode::DELETEFILE,
        // 147 => KeyCode::XFER,
@@ -193,13 +196,13 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 152 => KeyCode::COFFEE,
        // 153 => KeyCode::ROTATE_DISPLAY,
        // 154 => KeyCode::CYCLEWINDOWS,
-        // 155 => KeyCode::MAIL,
-        // 156 => KeyCode::BOOKMARKS,
+        155 => KeyCode::LaunchMail,
+        156 => KeyCode::BrowserFavorites, // BOOKMARKS
        // 157 => KeyCode::COMPUTER,
-        // 158 => KeyCode::BACK,
-        // 159 => KeyCode::FORWARD,
+        158 => KeyCode::BrowserBack,
+        159 => KeyCode::BrowserForward,
        // 160 => KeyCode::CLOSECD,
-        // 161 => KeyCode::EJECTCD,
+        161 => KeyCode::Eject, // EJECTCD
        // 162 => KeyCode::EJECTCLOSECD,
        163 => KeyCode::MediaTrackNext,
        164 => KeyCode::MediaPlayPause,
@@ -209,9 +212,9 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 168 => KeyCode::REWIND,
        // 169 => KeyCode::PHONE,
        // 170 => KeyCode::ISO,
-        // 171 => KeyCode::CONFIG,
-        // 172 => KeyCode::HOMEPAGE,
-        // 173 => KeyCode::REFRESH,
+        171 => KeyCode::MediaSelect, // CONFIG
+        172 => KeyCode::BrowserHome,
+        173 => KeyCode::BrowserRefresh,
        // 174 => KeyCode::EXIT,
        // 175 => KeyCode::MOVE,
        // 176 => KeyCode::EDIT,
@@ -250,7 +253,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 214 => KeyCode::QUESTION,
        // 215 => KeyCode::EMAIL,
        // 216 => KeyCode::CHAT,
-        // 217 => KeyCode::SEARCH,
+        217 => KeyCode::BrowserSearch,
        // 218 => KeyCode::CONNECT,
        // 219 => KeyCode::FINANCE,
        // 220 => KeyCode::SPORT,
@@ -419,10 +422,32 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::SuperLeft => Some(125),
        KeyCode::SuperRight => Some(126),
        KeyCode::ContextMenu => Some(127),
+        KeyCode::BrowserStop => Some(128),
+        KeyCode::Again => Some(129),
+        KeyCode::Props => Some(130),
+        KeyCode::Undo => Some(131),
+        KeyCode::Select => Some(132),
+        KeyCode::Copy => Some(133),
+        KeyCode::Open => Some(134),
+        KeyCode::Paste => Some(135),
+        KeyCode::Find => Some(136),
+        KeyCode::Cut => Some(137),
+        KeyCode::Help => Some(138),
+        KeyCode::LaunchApp2 => Some(140),
+        KeyCode::WakeUp => Some(143),
+        KeyCode::LaunchApp1 => Some(144),
+        KeyCode::LaunchMail => Some(155),
+        KeyCode::BrowserFavorites => Some(156),
+        KeyCode::BrowserBack => Some(158),
+        KeyCode::BrowserForward => Some(159),
+        KeyCode::Eject => Some(161),
        KeyCode::MediaTrackNext => Some(163),
        KeyCode::MediaPlayPause => Some(164),
        KeyCode::MediaTrackPrevious => Some(165),
        KeyCode::MediaStop => Some(166),
+        KeyCode::MediaSelect => Some(171),
+        KeyCode::BrowserHome => Some(172),
+        KeyCode::BrowserRefresh => Some(173),
        KeyCode::F13 => Some(183),
        KeyCode::F14 => Some(184),
        KeyCode::F15 => Some(185),
@@ -435,6 +460,7 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::F22 => Some(192),
        KeyCode::F23 => Some(193),
        KeyCode::F24 => Some(194),
+        KeyCode::BrowserSearch => Some(217),
        _ => None,
    }
 }
@@ -638,7 +664,7 @@ pub fn keysym_to_key(keysym: u32) -> Key {
        // keysyms::ISO_Release_Margin_Left => NamedKey::IsoReleaseMarginLeft,
        // keysyms::ISO_Release_Margin_Right => NamedKey::IsoReleaseMarginRight,
        // keysyms::ISO_Release_Both_Margins => NamedKey::IsoReleaseBothMargins,
-        // keysyms::ISO_Fast_Cursor_Left => NamedKey::IsoFastCursorLeft,
+        // keysyms::ISO_Fast_Cursor_Left => NamedKey::IsoFastPointerLeft,
        // keysyms::ISO_Fast_Cursor_Right => NamedKey::IsoFastCursorRight,
        // keysyms::ISO_Fast_Cursor_Up => NamedKey::IsoFastCursorUp,
        // keysyms::ISO_Fast_Cursor_Down => NamedKey::IsoFastCursorDown,
--- a/src/platform_impl/linux/common/xkb/mod.rs
+++ b/src/platform_impl/linux/common/xkb/mod.rs
@@ -183,7 +183,7 @@ pub struct KeyContext<'a> {
    scratch_buffer: &'a mut Vec<u8>,
 }

-impl<'a> KeyContext<'a> {
+impl KeyContext<'_> {
    pub fn process_key_event(
        &mut self,
        keycode: u32,
--- a/src/platform_impl/linux/mod.rs
+++ b/src/platform_impl/linux/mod.rs
@@ -107,61 +107,6 @@ impl Default for PlatformSpecificWindowAttributes {
 pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
    Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));

-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(u64);
-
-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self(raw_id)
-    }
-}
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        Self(0)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum DeviceId {
-    #[cfg(x11_platform)]
-    X(x11::DeviceId),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::DeviceId),
-}
-
-impl DeviceId {
-    pub const fn dummy() -> Self {
-        #[cfg(wayland_platform)]
-        return DeviceId::Wayland(wayland::DeviceId::dummy());
-        #[cfg(all(not(wayland_platform), x11_platform))]
-        return DeviceId::X(x11::DeviceId::dummy());
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum FingerId {
-    #[cfg(x11_platform)]
-    X(x11::FingerId),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::FingerId),
-}
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        #[cfg(wayland_platform)]
-        return FingerId::Wayland(wayland::FingerId::dummy());
-        #[cfg(all(not(wayland_platform), x11_platform))]
-        return FingerId::X(x11::FingerId::dummy());
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum MonitorHandle {
    #[cfg(x11_platform)]
@@ -276,7 +221,7 @@ pub(crate) enum PlatformCustomCursor {

 /// Hooks for X11 errors.
 #[cfg(x11_platform)]
-pub(crate) static mut XLIB_ERROR_HOOKS: Mutex<Vec<XlibErrorHook>> = Mutex::new(Vec::new());
+pub(crate) static XLIB_ERROR_HOOKS: Mutex<Vec<XlibErrorHook>> = Mutex::new(Vec::new());

 #[cfg(x11_platform)]
 unsafe extern "C" fn x_error_callback(
@@ -287,7 +232,7 @@ unsafe extern "C" fn x_error_callback(
    if let Ok(ref xconn) = *xconn_lock {
        // Call all the hooks.
        let mut error_handled = false;
-        for hook in unsafe { XLIB_ERROR_HOOKS.lock() }.unwrap().iter() {
+        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
            error_handled |= hook(display as *mut _, event as *mut _);
        }

@@ -332,14 +277,6 @@ pub enum EventLoop {
    X(x11::EventLoop),
 }

-#[derive(Clone)]
-pub enum EventLoopProxy {
-    #[cfg(x11_platform)]
-    X(x11::EventLoopProxy),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopProxy),
-}
-
 impl EventLoop {
    pub(crate) fn new(
        attributes: &PlatformSpecificEventLoopAttributes,
@@ -349,8 +286,8 @@ impl EventLoop {
                "Initializing the event loop outside of the main thread is a significant \
                 cross-platform compatibility hazard. If you absolutely need to create an \
                 EventLoop on a different thread, you can use the \
-                 `EventLoopBuilderExtX11::any_thread` or `EventLoopBuilderExtWayland::any_thread` \
-                 functions."
+                 `EventLoopBuilderExtX11::with_any_thread` or \
+                 `EventLoopBuilderExtWayland::with_any_thread` functions."
            );
        }

@@ -423,15 +360,18 @@ impl EventLoop {
        }
    }

-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app(app))
+    pub fn run<A: ApplicationHandler>(
+        self,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run(init_closure))
    }

-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_on_demand<A: ApplicationHandler>(
        &mut self,
-        app: A,
+        init_closure: impl FnOnce(&dyn ActiveEventLoop) -> A,
    ) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app_on_demand(app))
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_on_demand(init_closure))
    }

    pub fn pump_app_events<A: ApplicationHandler>(
@@ -459,65 +399,6 @@ impl AsRawFd for EventLoop {
    }
 }

-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.wake_up())
-    }
-}
-
-#[derive(Clone)]
-#[allow(dead_code)]
-pub(crate) enum OwnedDisplayHandle {
-    #[cfg(x11_platform)]
-    X(Arc<XConnection>),
-    #[cfg(wayland_platform)]
-    Wayland(wayland_client::Connection),
-}
-
-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        use std::ptr::NonNull;
-
-        match self {
-            #[cfg(x11_platform)]
-            Self::X(xconn) => Ok(rwh_06::XlibDisplayHandle::new(
-                NonNull::new(xconn.display.cast()),
-                xconn.default_screen_index() as _,
-            )
-            .into()),
-
-            #[cfg(wayland_platform)]
-            Self::Wayland(conn) => {
-                use sctk::reexports::client::Proxy;
-
-                Ok(rwh_06::WaylandDisplayHandle::new(
-                    NonNull::new(conn.display().id().as_ptr().cast()).unwrap(),
-                )
-                .into())
-            },
-        }
-    }
-}
-
-impl PartialEq for OwnedDisplayHandle {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            #[cfg(x11_platform)]
-            (Self::X(this), Self::X(other)) => Arc::as_ptr(this).eq(&Arc::as_ptr(other)),
-            #[cfg(wayland_platform)]
-            (Self::Wayland(this), Self::Wayland(other)) => this.eq(other),
-            #[cfg(all(x11_platform, wayland_platform))]
-            _ => false,
-        }
-    }
-}
-
-impl Eq for OwnedDisplayHandle {}
-
 /// Returns the minimum `Option<Duration>`, taking into account that `None`
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)
--- a/src/platform_impl/linux/wayland/event_loop/mod.rs
+++ b/src/platform_impl/linux/wayland/event_loop/mod.rs
@@ -16,7 +16,10 @@ use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
 use crate::error::{EventLoopError, OsError, RequestError};
 use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
+use crate::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
+};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::min_timeout;
 use crate::platform_impl::PlatformCustomCursor;
@@ -25,12 +28,13 @@ use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme}
 mod proxy;
 pub mod sink;

-pub use proxy::EventLoopProxy;
+use proxy::EventLoopProxy;
 use sink::EventSink;

 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
-use super::{logical_to_physical_rounded, DeviceId, WindowId};
+use super::{logical_to_physical_rounded, WindowId};
+pub use crate::event_loop::EventLoopProxy as CoreEventLoopProxy;

 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;

@@ -48,7 +52,7 @@ pub struct EventLoop {
    wayland_dispatcher: WaylandDispatcher,

    /// Connection to the wayland server.
-    connection: Connection,
+    handle: Arc<OwnedDisplayHandle>,

    /// Event loop window target.
    active_event_loop: ActiveEventLoop,
@@ -116,11 +120,12 @@ impl EventLoop {
            })
            .map_err(|err| os_error!(err))?;

+        let handle = Arc::new(OwnedDisplayHandle::new(connection));
        let active_event_loop = ActiveEventLoop {
-            connection: connection.clone(),
+            handle: handle.clone(),
            wayland_dispatcher: wayland_dispatcher.clone(),
            event_loop_awakener,
-            event_loop_proxy: EventLoopProxy::new(ping),
+            event_loop_proxy: EventLoopProxy::new(ping).into(),
            queue_handle,
            control_flow: Cell::new(ControlFlow::default()),
            exit: Cell::new(None),
@@ -132,7 +137,7 @@ impl EventLoop {
            compositor_updates: Vec::new(),
            buffer_sink: EventSink::default(),
            window_ids: Vec::new(),
-            connection,
+            handle,
            wayland_dispatcher,
            event_loop,
            active_event_loop,
@@ -141,15 +146,21 @@ impl EventLoop {
        Ok(event_loop)
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<A: ApplicationHandler>(
+        mut self,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.run_on_demand(init_closure)
    }

-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_on_demand<A: ApplicationHandler>(
        &mut self,
-        mut app: A,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
    ) -> Result<(), EventLoopError> {
        self.active_event_loop.clear_exit();
+
+        let mut app = init_closure(&self.active_event_loop);
+
        let exit = loop {
            match self.pump_app_events(None, &mut app) {
                PumpStatus::Exit(0) => {
@@ -193,8 +204,6 @@ impl EventLoop {
        if let Some(code) = self.exit_code() {
            self.loop_running = false;

-            app.exiting(&self.active_event_loop);
-
            PumpStatus::Exit(code)
        } else {
            PumpStatus::Continue
@@ -226,7 +235,7 @@ impl EventLoop {
            //
            // Checking for flush error is essential to perform an exit with error, since
            // once we have a protocol error, we could get stuck retrying...
-            if self.connection.flush().is_err() {
+            if self.handle.connection.flush().is_err() {
                self.set_exit_code(1);
                return;
            }
@@ -312,13 +321,12 @@ impl EventLoop {
                let old_physical_size = physical_size;

                let new_surface_size = Arc::new(Mutex::new(physical_size));
-                let root_window_id = crate::window::WindowId(window_id);
                let event = WindowEvent::ScaleFactorChanged {
                    scale_factor,
                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
                };

-                app.window_event(&self.active_event_loop, root_window_id, event);
+                app.window_event(&self.active_event_loop, window_id, event);

                let physical_size = *new_surface_size.lock().unwrap();
                drop(new_surface_size);
@@ -361,13 +369,11 @@ impl EventLoop {
                    size
                });

-                let window_id = crate::window::WindowId(window_id);
                let event = WindowEvent::SurfaceResized(physical_size);
                app.window_event(&self.active_event_loop, window_id, event);
            }

            if compositor_update.close_window {
-                let window_id = crate::window::WindowId(window_id);
                app.window_event(&self.active_event_loop, window_id, WindowEvent::CloseRequested);
            }
        }
@@ -437,8 +443,7 @@ impl EventLoop {
            });

            if let Some(event) = event {
-                let window_id = crate::window::WindowId(*window_id);
-                app.window_event(&self.active_event_loop, window_id, event);
+                app.window_event(&self.active_event_loop, *window_id, event);
            }
        }

@@ -543,7 +548,7 @@ impl AsRawFd for EventLoop {

 pub struct ActiveEventLoop {
    /// Event loop proxy
-    event_loop_proxy: EventLoopProxy,
+    event_loop_proxy: CoreEventLoopProxy,

    /// The event loop wakeup source.
    pub event_loop_awakener: calloop::ping::Ping,
@@ -564,17 +569,13 @@ pub struct ActiveEventLoop {
    /// Dispatcher of Wayland events.
    pub wayland_dispatcher: WaylandDispatcher,

-    /// Connection to the wayland server.
-    pub connection: Connection,
+    /// Handle for the underlying event loop.
+    pub handle: Arc<OwnedDisplayHandle>,
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> crate::event_loop::EventLoopProxy {
-        crate::event_loop::EventLoopProxy {
-            event_loop_proxy: crate::platform_impl::EventLoopProxy::Wayland(
-                self.event_loop_proxy.clone(),
-            ),
-        }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        self.event_loop_proxy.clone()
    }

    fn set_control_flow(&self, control_flow: ControlFlow) {
@@ -635,13 +636,10 @@ impl RootActiveEventLoop for ActiveEventLoop {
        None
    }

-    fn owned_display_handle(&self) -> crate::event_loop::OwnedDisplayHandle {
-        crate::event_loop::OwnedDisplayHandle {
-            platform: crate::platform_impl::OwnedDisplayHandle::Wayland(self.connection.clone()),
-        }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(self.handle.clone())
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
@@ -661,8 +659,23 @@ impl ActiveEventLoop {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        self.handle.display_handle()
+    }
+}
+
+pub struct OwnedDisplayHandle {
+    pub(crate) connection: Connection,
+}
+
+impl OwnedDisplayHandle {
+    fn new(connection: Connection) -> Self {
+        Self { connection }
+    }
+}
+
+impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        use sctk::reexports::client::Proxy;

--- a/src/platform_impl/linux/wayland/event_loop/proxy.rs
+++ b/src/platform_impl/linux/wayland/event_loop/proxy.rs
@@ -1,19 +1,30 @@
 //! An event loop proxy.

+use std::sync::Arc;
+
 use sctk::reexports::calloop::ping::Ping;

+use crate::event_loop::{EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider};
+
 /// A handle that can be sent across the threads and used to wake up the `EventLoop`.
-#[derive(Clone)]
 pub struct EventLoopProxy {
    ping: Ping,
 }

+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.ping.ping();
+    }
+}
+
 impl EventLoopProxy {
    pub fn new(ping: Ping) -> Self {
        Self { ping }
    }
+}

-    pub fn wake_up(&self) {
-        self.ping.ping();
+impl From<EventLoopProxy> for CoreEventLoopProxy {
+    fn from(value: EventLoopProxy) -> Self {
+        CoreEventLoopProxy::new(Arc::new(value))
    }
 }
--- a/src/platform_impl/linux/wayland/event_loop/sink.rs
+++ b/src/platform_impl/linux/wayland/event_loop/sink.rs
@@ -2,10 +2,8 @@

 use std::vec::Drain;

-use super::{DeviceId, WindowId};
-use crate::event::{DeviceEvent, DeviceId as RootDeviceId, Event, WindowEvent};
-use crate::platform_impl::platform::DeviceId as PlatformDeviceId;
-use crate::window::WindowId as RootWindowId;
+use crate::event::{DeviceEvent, Event, WindowEvent};
+use crate::window::WindowId;

 /// An event loop's sink to deliver events from the Wayland event callbacks
 /// to the winit's user.
@@ -27,17 +25,14 @@ impl EventSink {

    /// Add new device event to a queue.
    #[inline]
-    pub fn push_device_event(&mut self, event: DeviceEvent, device_id: DeviceId) {
-        self.window_events.push(Event::DeviceEvent {
-            event,
-            device_id: RootDeviceId(PlatformDeviceId::Wayland(device_id)),
-        });
+    pub fn push_device_event(&mut self, event: DeviceEvent) {
+        self.window_events.push(Event::DeviceEvent { event, device_id: None });
    }

    /// Add new window event to a queue.
    #[inline]
    pub fn push_window_event(&mut self, event: WindowEvent, window_id: WindowId) {
-        self.window_events.push(Event::WindowEvent { event, window_id: RootWindowId(window_id) });
+        self.window_events.push(Event::WindowEvent { event, window_id });
    }

    #[inline]
--- a/src/platform_impl/linux/wayland/mod.rs
+++ b/src/platform_impl/linux/wayland/mod.rs
@@ -1,6 +1,6 @@
 //! Winit's Wayland backend.

-pub use event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy};
+pub use event_loop::{ActiveEventLoop, EventLoop};
 pub use output::{MonitorHandle, VideoModeHandle};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::Proxy;
@@ -8,7 +8,7 @@ pub use window::Window;

 pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
 use crate::dpi::{LogicalSize, PhysicalSize};
-pub use crate::platform_impl::platform::WindowId;
+use crate::window::WindowId;

 mod event_loop;
 mod output;
@@ -17,29 +17,10 @@ mod state;
 mod types;
 mod window;

-/// Dummy device id, since Wayland doesn't have device events.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId;
-
-impl DeviceId {
-    pub const fn dummy() -> Self {
-        DeviceId
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId(i32);
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId(0)
-    }
-}
-
 /// Get the WindowId out of the surface.
 #[inline]
 fn make_wid(surface: &WlSurface) -> WindowId {
-    WindowId(surface.id().as_ptr() as u64)
+    WindowId::from_raw(surface.id().as_ptr() as usize)
 }

 /// The default routine does floor, but we need round on Wayland.
--- a/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
@@ -17,7 +17,7 @@ use crate::keyboard::ModifiersState;
 use crate::platform_impl::common::xkb::Context;
 use crate::platform_impl::wayland::event_loop::sink::EventSink;
 use crate::platform_impl::wayland::state::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId, WindowId};
+use crate::platform_impl::wayland::{self, WindowId};

 impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
    fn event(
@@ -369,10 +369,9 @@ fn key_input(
        None => return,
    };

-    let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));
    if let Some(mut key_context) = keyboard_state.xkb_context.key_context() {
        let event = key_context.process_key_event(keycode, state, repeat);
-        let event = WindowEvent::KeyboardInput { device_id, event, is_synthetic: false };
+        let event = WindowEvent::KeyboardInput { device_id: None, event, is_synthetic: false };
        event_sink.push_window_event(event, window_id);
    }
 }
--- a/src/platform_impl/linux/wayland/seat/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/mod.rs
@@ -40,6 +40,9 @@ pub struct WinitSeatState {
    /// The mapping from touched points to the surfaces they're present.
    touch_map: AHashMap<i32, TouchPoint>,

+    /// Id of the first touch event.
+    first_touch_id: Option<i32>,
+
    /// The text input bound on the seat.
    text_input: Option<Arc<ZwpTextInputV3>>,

--- a/src/platform_impl/linux/wayland/seat/pointer/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/mod.rs
@@ -27,10 +27,10 @@ use sctk::seat::pointer::{
 use sctk::seat::SeatState;

 use crate::dpi::{LogicalPosition, PhysicalPosition};
-use crate::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent};
+use crate::event::{ElementState, MouseButton, MouseScrollDelta, PointerSource, PointerKind, TouchPhase, WindowEvent};

 use crate::platform_impl::wayland::state::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId, WindowId};
+use crate::platform_impl::wayland::{self, WindowId};

 pub mod relative_pointer;

@@ -59,8 +59,6 @@ impl PointerHandler for WinitState {
            },
        };

-        let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));
-
        for event in events {
            let surface = &event.surface;

@@ -124,18 +122,20 @@ impl PointerHandler for WinitState {
                },
                // Regular events on the main surface.
                PointerEventKind::Enter { .. } => {
-                    self.events_sink
-                        .push_window_event(WindowEvent::CursorEntered { device_id }, window_id);
+                    self.events_sink.push_window_event(
+                        WindowEvent::PointerEntered {
+                            primary: true,
+                            device_id: None,
+                            position,
+                            kind: PointerKind::Mouse,
+                        },
+                        window_id,
+                    );

                    window.pointer_entered(Arc::downgrade(themed_pointer));

                    // Set the currently focused surface.
                    pointer.winit_data().inner.lock().unwrap().surface = Some(window_id);
-
-                    self.events_sink.push_window_event(
-                        WindowEvent::CursorMoved { device_id, position },
-                        window_id,
-                    );
                },
                PointerEventKind::Leave { .. } => {
                    window.pointer_left(Arc::downgrade(themed_pointer));
@@ -143,12 +143,24 @@ impl PointerHandler for WinitState {
                    // Remove the active surface.
                    pointer.winit_data().inner.lock().unwrap().surface = None;

-                    self.events_sink
-                        .push_window_event(WindowEvent::CursorLeft { device_id }, window_id);
+                    self.events_sink.push_window_event(
+                        WindowEvent::PointerLeft {
+                            primary: true,
+                            device_id: None,
+                            position: Some(position),
+                            kind: PointerKind::Mouse,
+                        },
+                        window_id,
+                    );
                },
                PointerEventKind::Motion { .. } => {
                    self.events_sink.push_window_event(
-                        WindowEvent::CursorMoved { device_id, position },
+                        WindowEvent::PointerMoved {
+                            primary: true,
+                            device_id: None,
+                            position,
+                            source: PointerSource::Mouse,
+                        },
                        window_id,
                    );
                },
@@ -164,7 +176,13 @@ impl PointerHandler for WinitState {
                        ElementState::Released
                    };
                    self.events_sink.push_window_event(
-                        WindowEvent::MouseInput { device_id, state, button },
+                        WindowEvent::PointerButton {
+                            primary: true,
+                            device_id: None,
+                            state,
+                            position,
+                            button: button.into(),
+                        },
                        window_id,
                    );
                },
@@ -209,7 +227,7 @@ impl PointerHandler for WinitState {
                    };

                    self.events_sink.push_window_event(
-                        WindowEvent::MouseWheel { device_id, delta, phase },
+                        WindowEvent::MouseWheel { device_id: None, delta, phase },
                        window_id,
                    )
                },
--- a/src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs
@@ -66,10 +66,9 @@ impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerS
            },
            _ => return,
        };
-        state.events_sink.push_device_event(
-            DeviceEvent::MouseMotion { delta: (dx_unaccel, dy_unaccel) },
-            super::DeviceId,
-        );
+        state
+            .events_sink
+            .push_device_event(DeviceEvent::PointerMotion { delta: (dx_unaccel, dy_unaccel) });
    }
 }

--- a/src/platform_impl/linux/wayland/seat/touch/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/touch/mod.rs
@@ -8,9 +8,9 @@ use sctk::seat::touch::{TouchData, TouchHandler};
 use tracing::warn;

 use crate::dpi::LogicalPosition;
-use crate::event::{Touch, TouchPhase, WindowEvent};
+use crate::event::{ButtonSource, ElementState, FingerId, PointerKind, PointerSource, WindowEvent};
+use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::state::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId, FingerId};

 impl TouchHandler for WinitState {
    fn down(
@@ -40,20 +40,33 @@ impl TouchHandler for WinitState {

        // Update the state of the point.
        let location = LogicalPosition::<f64>::from(position);
+        // Only update primary finger once we don't have any touch.
+        if seat_state.touch_map.is_empty() {
+            seat_state.first_touch_id = Some(id);
+        }
+        let primary = seat_state.first_touch_id == Some(id);
        seat_state.touch_map.insert(id, TouchPoint { surface, location });

+        let position = location.to_physical(scale_factor);
+        let finger_id = FingerId::from_raw(id as usize);
+
        self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
-                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                    DeviceId,
-                )),
-                phase: TouchPhase::Started,
-                location: location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+            WindowEvent::PointerEntered {
+                device_id: None,
+                primary,
+                position,
+                kind: PointerKind::Touch(finger_id),
+            },
+            window_id,
+        );
+        self.events_sink.push_window_event(
+            WindowEvent::PointerButton {
+                device_id: None,
+                primary,
+                state: ElementState::Pressed,
+                position,
+                button: ButtonSource::Touch { finger_id, force: None },
+            },
            window_id,
        );
    }
@@ -81,24 +94,41 @@ impl TouchHandler for WinitState {
            None => return,
        };

+        // Update the primary touch point.
+        let primary = seat_state.first_touch_id == Some(id);
+        // Reset primary finger once all the other fingers are lifted to not transfer primary
+        // finger to some other finger and still accept it when it's briefly moved between the
+        // windows.
+        if seat_state.touch_map.is_empty() {
+            seat_state.first_touch_id = None;
+        }
+
        let window_id = wayland::make_wid(&touch_point.surface);
        let scale_factor = match self.windows.get_mut().get(&window_id) {
            Some(window) => window.lock().unwrap().scale_factor(),
            None => return,
        };

+        let position = touch_point.location.to_physical(scale_factor);
+        let finger_id = FingerId::from_raw(id as usize);
+
        self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
-                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                    DeviceId,
-                )),
-                phase: TouchPhase::Ended,
-                location: touch_point.location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+            WindowEvent::PointerButton {
+                device_id: None,
+                primary,
+                state: ElementState::Released,
+                position,
+                button: ButtonSource::Touch { finger_id, force: None },
+            },
+            window_id,
+        );
+        self.events_sink.push_window_event(
+            WindowEvent::PointerLeft {
+                device_id: None,
+                primary,
+                position: Some(position),
+                kind: PointerKind::Touch(finger_id),
+            },
            window_id,
        );
    }
@@ -126,6 +156,8 @@ impl TouchHandler for WinitState {
            None => return,
        };

+        let primary = seat_state.first_touch_id == Some(id);
+
        let window_id = wayland::make_wid(&touch_point.surface);
        let scale_factor = match self.windows.get_mut().get(&window_id) {
            Some(window) => window.lock().unwrap().scale_factor(),
@@ -135,17 +167,15 @@ impl TouchHandler for WinitState {
        touch_point.location = LogicalPosition::<f64>::from(position);

        self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
-                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                    DeviceId,
-                )),
-                phase: TouchPhase::Moved,
-                location: touch_point.location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+            WindowEvent::PointerMoved {
+                device_id: None,
+                primary,
+                position: touch_point.location.to_physical(scale_factor),
+                source: PointerSource::Touch {
+                    finger_id: FingerId::from_raw(id as usize),
+                    force: None,
+                },
+            },
            window_id,
        );
    }
@@ -166,23 +196,21 @@ impl TouchHandler for WinitState {
                None => return,
            };

-            let location = touch_point.location.to_physical(scale_factor);
+            let primary = seat_state.first_touch_id == Some(id);
+            let position = touch_point.location.to_physical(scale_factor);

            self.events_sink.push_window_event(
-                WindowEvent::Touch(Touch {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    phase: TouchPhase::Cancelled,
-                    location,
-                    force: None,
-                    finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                        FingerId(id),
-                    )),
-                }),
+                WindowEvent::PointerLeft {
+                    device_id: None,
+                    primary,
+                    position: Some(position),
+                    kind: PointerKind::Touch(FingerId::from_raw(id as usize)),
+                },
                window_id,
            );
        }
+
+        seat_state.first_touch_id = None;
    }

    fn shape(
--- a/src/platform_impl/linux/wayland/types/xdg_activation.rs
+++ b/src/platform_impl/linux/wayland/types/xdg_activation.rs
@@ -14,8 +14,7 @@ use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_v1::

 use crate::event_loop::AsyncRequestSerial;
 use crate::platform_impl::wayland::state::WinitState;
-use crate::platform_impl::WindowId;
-use crate::window::ActivationToken;
+use crate::window::{ActivationToken, WindowId};

 pub struct XdgActivationState {
    xdg_activation: XdgActivationV1,
--- a/src/platform_impl/linux/wayland/window/mod.rs
+++ b/src/platform_impl/linux/wayland/window/mod.rs
@@ -16,8 +16,8 @@ use super::event_loop::sink::EventSink;
 use super::output::MonitorHandle;
 use super::state::WinitState;
 use super::types::xdg_activation::XdgActivationTokenData;
-use super::{ActiveEventLoop, WindowId};
-use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use super::ActiveEventLoop;
+use crate::dpi::{LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Ime, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
@@ -25,8 +25,8 @@ use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform_impl::{Fullscreen, MonitorHandle as PlatformMonitorHandle};
 use crate::window::{
    Cursor, CursorGrabMode, Fullscreen as CoreFullscreen, ImePurpose, ResizeDirection, Theme,
-    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons,
-    WindowId as CoreWindowId, WindowLevel,
+    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
+    WindowLevel,
 };

 pub(crate) mod state;
@@ -87,7 +87,7 @@ impl Window {
        let compositor = state.compositor_state.clone();
        let xdg_activation =
            state.xdg_activation.as_ref().map(|activation_state| activation_state.global().clone());
-        let display = event_loop_window_target.connection.display();
+        let display = event_loop_window_target.handle.connection.display();

        let size: Size = attributes.surface_size.unwrap_or(LogicalSize::new(800., 600.).into());

@@ -103,7 +103,7 @@ impl Window {
            state.xdg_shell.create_window(surface.clone(), default_decorations, &queue_handle);

        let mut window_state = WindowState::new(
-            event_loop_window_target.connection.clone(),
+            event_loop_window_target.handle.clone(),
            &event_loop_window_target.queue_handle,
            &state,
            size,
@@ -248,7 +248,6 @@ impl Drop for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::WaylandWindowHandle::new({
@@ -260,7 +259,6 @@ impl rwh_06::HasWindowHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::WaylandDisplayHandle::new({
@@ -273,8 +271,8 @@ impl rwh_06::HasDisplayHandle for Window {
 }

 impl CoreWindow for Window {
-    fn id(&self) -> CoreWindowId {
-        CoreWindowId(self.window_id)
+    fn id(&self) -> WindowId {
+        self.window_id
    }

    fn request_redraw(&self) {
@@ -305,9 +303,8 @@ impl CoreWindow for Window {
        crate::platform_impl::common::xkb::reset_dead_keys()
    }

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        Err(NotSupportedError::new("window position information is not available on Wayland")
-            .into())
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        (0, 0).into()
    }

    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
@@ -338,6 +335,10 @@ impl CoreWindow for Window {
        super::logical_to_physical_rounded(window_state.outer_size(), scale_factor)
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        PhysicalInsets::new(0, 0, 0, 0)
+    }
+
    fn set_min_surface_size(&self, min_size: Option<Size>) {
        let scale_factor = self.scale_factor();
        let min_size = min_size.map(|size| size.to_logical(scale_factor));
@@ -648,13 +649,11 @@ impl CoreWindow for Window {
    }

    /// Get the raw-window-handle v0.6 display handle.
-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

    /// Get the raw-window-handle v0.6 window handle.
-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
--- a/src/platform_impl/linux/wayland/window/state.rs
+++ b/src/platform_impl/linux/wayland/window/state.rs
@@ -10,7 +10,7 @@ use sctk::reexports::client::backend::ObjectId;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_shm::WlShm;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+use sctk::reexports::client::{Proxy, QueueHandle};
 use sctk::reexports::csd_frame::{
    DecorationsFrame, FrameAction, FrameClick, ResizeEdge, WindowState as XdgWindowState,
 };
@@ -31,6 +31,7 @@ use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use crate::cursor::CustomCursor as RootCustomCursor;
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalSize, Size};
 use crate::error::{NotSupportedError, RequestError};
+use crate::platform_impl::wayland::event_loop::OwnedDisplayHandle;
 use crate::platform_impl::wayland::logical_to_physical_rounded;
 use crate::platform_impl::wayland::seat::{
    PointerConstraintsState, WinitPointerData, WinitPointerDataExt, ZwpTextInputV3Ext,
@@ -38,8 +39,8 @@ use crate::platform_impl::wayland::seat::{
 use crate::platform_impl::wayland::state::{WindowCompositorUpdate, WinitState};
 use crate::platform_impl::wayland::types::cursor::{CustomCursor, SelectedCursor};
 use crate::platform_impl::wayland::types::kwin_blur::KWinBlurManager;
-use crate::platform_impl::{PlatformCustomCursor, WindowId};
-use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme};
+use crate::platform_impl::PlatformCustomCursor;
+use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, WindowId};

 #[cfg(feature = "sctk-adwaita")]
 pub type WinitFrame = sctk_adwaita::AdwaitaFrame<WinitState>;
@@ -52,7 +53,7 @@ const MIN_WINDOW_SIZE: LogicalSize<u32> = LogicalSize::new(2, 1);
 /// The state of the window which is being updated from the [`WinitState`].
 pub struct WindowState {
    /// The connection to Wayland server.
-    pub connection: Connection,
+    pub handle: Arc<OwnedDisplayHandle>,

    /// The `Shm` to set cursor.
    pub shm: WlShm,
@@ -161,7 +162,7 @@ pub struct WindowState {
 impl WindowState {
    /// Create new window state.
    pub fn new(
-        connection: Connection,
+        handle: Arc<OwnedDisplayHandle>,
        queue_handle: &QueueHandle<WinitState>,
        winit_state: &WinitState,
        initial_size: Size,
@@ -183,7 +184,7 @@ impl WindowState {
            blur: None,
            blur_manager: winit_state.kwin_blur_manager.clone(),
            compositor,
-            connection,
+            handle,
            csd_fails: false,
            cursor_grab_mode: GrabState::new(),
            selected_cursor: Default::default(),
@@ -693,7 +694,7 @@ impl WindowState {
        }

        self.apply_on_pointer(|pointer, _| {
-            if pointer.set_cursor(&self.connection, cursor_icon).is_err() {
+            if pointer.set_cursor(&self.handle.connection, cursor_icon).is_err() {
                warn!("Failed to set cursor to {:?}", cursor_icon);
            }
        })
--- a/src/platform_impl/linux/x11/activation.rs
+++ b/src/platform_impl/linux/x11/activation.rs
@@ -165,14 +165,14 @@ fn push_display(buffer: &mut Vec<u8>, display: &impl std::fmt::Display) {
        buffer: &'a mut Vec<u8>,
    }

-    impl<'a> std::fmt::Write for Writer<'a> {
+    impl std::fmt::Write for Writer<'_> {
        fn write_str(&mut self, s: &str) -> std::fmt::Result {
            self.buffer.extend_from_slice(s.as_bytes());
            Ok(())
        }
    }

-    write!(Writer { buffer }, "{}", display).unwrap();
+    write!(Writer { buffer }, "{display}").unwrap();
 }

 #[cfg(test)]
--- a/src/platform_impl/linux/x11/event_processor.rs
+++ b/src/platform_impl/linux/x11/event_processor.rs
@@ -22,8 +22,9 @@ use xkbcommon_dl::xkb_mod_mask_t;

 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::event::{
-    DeviceEvent, ElementState, Event, Ime, MouseButton, MouseScrollDelta, RawKeyEvent,
-    SurfaceSizeWriter, Touch, TouchPhase, WindowEvent,
+    ButtonSource, DeviceEvent, DeviceId, ElementState, Event, FingerId, Ime, MouseButton,
+    MouseScrollDelta, PointerKind, PointerSource, RawKeyEvent, SurfaceSizeWriter, TouchPhase,
+    WindowEvent,
 };
 use crate::keyboard::ModifiersState;
 use crate::platform_impl::common::xkb::{self, XkbState};
@@ -33,8 +34,8 @@ use crate::platform_impl::platform::x11::ActiveEventLoop;
 use crate::platform_impl::x11::atoms::*;
 use crate::platform_impl::x11::util::cookie::GenericEventCookie;
 use crate::platform_impl::x11::{
-    mkdid, mkfid, mkwid, util, CookieResultExt, Device, DeviceId, DeviceInfo, Dnd, DndState,
-    ImeReceiver, ScrollOrientation, UnownedWindow, WindowId,
+    mkdid, mkwid, util, CookieResultExt, Device, DeviceInfo, Dnd, DndState, ImeReceiver,
+    ScrollOrientation, UnownedWindow, WindowId,
 };

 /// The maximum amount of X modifiers to replay.
@@ -142,8 +143,18 @@ impl EventProcessor {
    {
        let event_type = xev.get_type();

-        if self.filter_event(xev) {
-            if event_type == xlib::KeyPress || event_type == xlib::KeyRelease {
+        // If we have IME disabled, don't try to `filter_event`, since only IME can consume them
+        // and forward back. This is not desired for e.g. games since some IMEs may delay the input
+        // and game can toggle IME back when e.g. typing into some field where latency won't really
+        // matter.
+        if event_type == xlib::KeyPress || event_type == xlib::KeyRelease {
+            let ime = self.target.ime.as_ref();
+            let window = self.active_window.map(|window| window as XWindow);
+            let forward_to_ime = ime
+                .and_then(|ime| window.map(|window| ime.borrow().is_ime_allowed(window)))
+                .unwrap_or(false);
+
+            if forward_to_ime && self.filter_event(xev) {
                let xev: &XKeyEvent = xev.as_ref();
                if self.xmodmap.is_modifier(xev.keycode as u8) {
                    // Don't grow the buffer past the `MAX_MOD_REPLAY_LEN`. This could happen
@@ -156,7 +167,8 @@ impl EventProcessor {
                    self.xfiltered_modifiers.push_front(xev.serial);
                }
            }
-            return;
+        } else {
+            self.filter_event(xev);
        }

        match event_type {
@@ -238,15 +250,8 @@ impl EventProcessor {
                        self.xinput2_unfocused(xev, &mut callback);
                    },
                    xinput2::XI_TouchBegin | xinput2::XI_TouchUpdate | xinput2::XI_TouchEnd => {
-                        let phase = match evtype {
-                            xinput2::XI_TouchBegin => TouchPhase::Started,
-                            xinput2::XI_TouchUpdate => TouchPhase::Moved,
-                            xinput2::XI_TouchEnd => TouchPhase::Ended,
-                            _ => unreachable!(),
-                        };
-
                        let xev: &XIDeviceEvent = unsafe { xev.as_event() };
-                        self.xinput2_touch(xev, phase, &mut callback);
+                        self.xinput2_touch(xev, evtype, &mut callback);
                    },
                    xinput2::XI_RawButtonPress | xinput2::XI_RawButtonRelease => {
                        let state = match evtype {
@@ -326,7 +331,7 @@ impl EventProcessor {
        let mut devices = self.devices.borrow_mut();
        if let Some(info) = DeviceInfo::get(&self.target.xconn, device as _) {
            for info in info.iter() {
-                devices.insert(DeviceId(info.deviceid as _), Device::new(info));
+                devices.insert(mkdid(info.deviceid as xinput::DeviceId), Device::new(info));
            }
        }
    }
@@ -336,7 +341,7 @@ impl EventProcessor {
        F: Fn(&Arc<UnownedWindow>) -> Ret,
    {
        let mut deleted = false;
-        let window_id = WindowId(window_id as _);
+        let window_id = WindowId::from_raw(window_id as _);
        let result = self
            .target
            .windows
@@ -805,7 +810,7 @@ impl EventProcessor {

        // In the event that the window's been destroyed without being dropped first, we
        // cleanup again here.
-        self.target.windows.borrow_mut().remove(&WindowId(window as _));
+        self.target.windows.borrow_mut().remove(&WindowId::from_raw(window as _));

        // Since all XIM stuff needs to happen from the same thread, we destroy the input
        // context here instead of when dropping the window.
@@ -878,7 +883,6 @@ impl EventProcessor {
        };

        let window_id = mkwid(window);
-        let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);

        let keycode = xev.keycode as _;

@@ -942,7 +946,11 @@ impl EventProcessor {
                let event = key_processor.process_key_event(keycode, state, repeat);
                let event = Event::WindowEvent {
                    window_id,
-                    event: WindowEvent::KeyboardInput { device_id, event, is_synthetic: false },
+                    event: WindowEvent::KeyboardInput {
+                        device_id: None,
+                        event,
+                        is_synthetic: false,
+                    },
                };
                callback(&self.target, event);
            }
@@ -1012,7 +1020,7 @@ impl EventProcessor {
        F: FnMut(&ActiveEventLoop, Event),
    {
        let window_id = mkwid(event.event as xproto::Window);
-        let device_id = mkdid(event.deviceid as xinput::DeviceId);
+        let device_id = Some(mkdid(event.deviceid as xinput::DeviceId));

        // Set the timestamp.
        self.target.xconn.set_timestamp(event.time as xproto::Timestamp);
@@ -1022,16 +1030,30 @@ impl EventProcessor {
            return;
        }

+        let position = PhysicalPosition::new(event.event_x, event.event_y);
+
        let event = match event.detail as u32 {
-            xlib::Button1 => {
-                WindowEvent::MouseInput { device_id, state, button: MouseButton::Left }
+            xlib::Button1 => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Left.into(),
            },
-            xlib::Button2 => {
-                WindowEvent::MouseInput { device_id, state, button: MouseButton::Middle }
+            xlib::Button2 => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Middle.into(),
            },

-            xlib::Button3 => {
-                WindowEvent::MouseInput { device_id, state, button: MouseButton::Right }
+            xlib::Button3 => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Right.into(),
            },

            // Suppress emulated scroll wheel clicks, since we handle the real motion events for
@@ -1049,10 +1071,28 @@ impl EventProcessor {
                },
                phase: TouchPhase::Moved,
            },
-            8 => WindowEvent::MouseInput { device_id, state, button: MouseButton::Back },
+            8 => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Back.into(),
+            },

-            9 => WindowEvent::MouseInput { device_id, state, button: MouseButton::Forward },
-            x => WindowEvent::MouseInput { device_id, state, button: MouseButton::Other(x as u16) },
+            9 => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Forward.into(),
+            },
+            x => WindowEvent::PointerButton {
+                device_id,
+                primary: true,
+                state,
+                position,
+                button: MouseButton::Other(x as u16).into(),
+            },
        };

        let event = Event::WindowEvent { window_id, event };
@@ -1066,7 +1106,7 @@ impl EventProcessor {
        // Set the timestamp.
        self.target.xconn.set_timestamp(event.time as xproto::Timestamp);

-        let device_id = mkdid(event.deviceid as xinput::DeviceId);
+        let device_id = Some(mkdid(event.deviceid as xinput::DeviceId));
        let window = event.event as xproto::Window;
        let window_id = mkwid(window);
        let new_cursor_pos = (event.event_x, event.event_y);
@@ -1081,7 +1121,12 @@ impl EventProcessor {

            let event = Event::WindowEvent {
                window_id,
-                event: WindowEvent::CursorMoved { device_id, position },
+                event: WindowEvent::PointerMoved {
+                    device_id,
+                    primary: true,
+                    position,
+                    source: PointerSource::Mouse,
+                },
            };
            callback(&self.target, event);
        } else if cursor_moved.is_none() {
@@ -1093,7 +1138,7 @@ impl EventProcessor {
            slice::from_raw_parts(event.valuators.mask, event.valuators.mask_len as usize)
        };
        let mut devices = self.devices.borrow_mut();
-        let physical_device = match devices.get_mut(&DeviceId(event.sourceid as xinput::DeviceId)) {
+        let physical_device = match devices.get_mut(&mkdid(event.sourceid as xinput::DeviceId)) {
            Some(device) => device,
            None => return,
        };
@@ -1152,7 +1197,7 @@ impl EventProcessor {
                if device_info.deviceid == event.sourceid
                    || device_info.attachment == event.sourceid
                {
-                    let device_id = DeviceId(device_info.deviceid as _);
+                    let device_id = mkdid(device_info.deviceid as xinput::DeviceId);
                    if let Some(device) = devices.get_mut(&device_id) {
                        device.reset_scroll_position(device_info);
                    }
@@ -1161,15 +1206,17 @@ impl EventProcessor {
        }

        if self.window_exists(window) {
+            let device_id = Some(device_id);
            let position = PhysicalPosition::new(event.event_x, event.event_y);

-            let event =
-                Event::WindowEvent { window_id, event: WindowEvent::CursorEntered { device_id } };
-            callback(&self.target, event);
-
            let event = Event::WindowEvent {
                window_id,
-                event: WindowEvent::CursorMoved { device_id, position },
+                event: WindowEvent::PointerEntered {
+                    device_id,
+                    primary: true,
+                    position,
+                    kind: PointerKind::Mouse,
+                },
            };
            callback(&self.target, event);
        }
@@ -1189,8 +1236,11 @@ impl EventProcessor {
        if self.window_exists(window) {
            let event = Event::WindowEvent {
                window_id: mkwid(window),
-                event: WindowEvent::CursorLeft {
-                    device_id: mkdid(event.deviceid as xinput::DeviceId),
+                event: WindowEvent::PointerLeft {
+                    device_id: Some(mkdid(event.deviceid as xinput::DeviceId)),
+                    primary: true,
+                    position: Some(PhysicalPosition::new(event.event_x, event.event_y)),
+                    kind: PointerKind::Mouse,
                },
            };
            callback(&self.target, event);
@@ -1241,16 +1291,20 @@ impl EventProcessor {

        // The deviceid for this event is for a keyboard instead of a pointer,
        // so we have to do a little extra work.
-        let pointer_id = self
+        let device_id = self
            .devices
            .borrow()
-            .get(&DeviceId(xev.deviceid as xinput::DeviceId))
-            .map(|device| device.attachment)
-            .unwrap_or(2);
+            .get(&mkdid(xev.deviceid as xinput::DeviceId))
+            .map(|device| mkdid(device.attachment as xinput::DeviceId));

        let event = Event::WindowEvent {
            window_id,
-            event: WindowEvent::CursorMoved { device_id: mkdid(pointer_id as _), position },
+            event: WindowEvent::PointerMoved {
+                device_id,
+                primary: true,
+                position,
+                source: PointerSource::Mouse,
+            },
        };
        callback(&self.target, event);
    }
@@ -1306,7 +1360,7 @@ impl EventProcessor {
        }
    }

-    fn xinput2_touch<F>(&mut self, xev: &XIDeviceEvent, phase: TouchPhase, mut callback: F)
+    fn xinput2_touch<F>(&mut self, xev: &XIDeviceEvent, phase: i32, mut callback: F)
    where
        F: FnMut(&ActiveEventLoop, Event),
    {
@@ -1317,32 +1371,89 @@ impl EventProcessor {
        if self.window_exists(window) {
            let window_id = mkwid(window);
            let id = xev.detail as u32;
-            let location = PhysicalPosition::new(xev.event_x, xev.event_y);
+            let position = PhysicalPosition::new(xev.event_x, xev.event_y);

            // Mouse cursor position changes when touch events are received.
            // Only the first concurrently active touch ID moves the mouse cursor.
-            if is_first_touch(&mut self.first_touch, &mut self.num_touch, id, phase) {
+            let is_first_touch =
+                is_first_touch(&mut self.first_touch, &mut self.num_touch, id, phase);
+            if is_first_touch {
                let event = Event::WindowEvent {
                    window_id,
-                    event: WindowEvent::CursorMoved {
-                        device_id: mkdid(util::VIRTUAL_CORE_POINTER),
-                        position: location.cast(),
+                    event: WindowEvent::PointerMoved {
+                        device_id: None,
+                        primary: true,
+                        position: position.cast(),
+                        source: PointerSource::Mouse,
                    },
                };
                callback(&self.target, event);
            }

-            let event = Event::WindowEvent {
-                window_id,
-                event: WindowEvent::Touch(Touch {
-                    device_id: mkdid(xev.deviceid as xinput::DeviceId),
-                    phase,
-                    location,
-                    force: None, // TODO
-                    finger_id: mkfid(id),
-                }),
-            };
-            callback(&self.target, event)
+            let device_id = Some(mkdid(xev.deviceid as xinput::DeviceId));
+            let finger_id = FingerId::from_raw(id as usize);
+
+            match phase {
+                xinput2::XI_TouchBegin => {
+                    let event = Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerEntered {
+                            device_id,
+                            primary: is_first_touch,
+                            position,
+                            kind: PointerKind::Touch(finger_id),
+                        },
+                    };
+                    callback(&self.target, event);
+                    let event = Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerButton {
+                            device_id,
+                            primary: is_first_touch,
+                            state: ElementState::Pressed,
+                            position,
+                            button: ButtonSource::Touch { finger_id, force: None },
+                        },
+                    };
+                    callback(&self.target, event);
+                },
+                xinput2::XI_TouchUpdate => {
+                    let event = Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerMoved {
+                            device_id,
+                            primary: is_first_touch,
+                            position,
+                            source: PointerSource::Touch { finger_id, force: None },
+                        },
+                    };
+                    callback(&self.target, event);
+                },
+                xinput2::XI_TouchEnd => {
+                    let event = Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerButton {
+                            device_id,
+                            primary: is_first_touch,
+                            state: ElementState::Released,
+                            position,
+                            button: ButtonSource::Touch { finger_id, force: None },
+                        },
+                    };
+                    callback(&self.target, event);
+                    let event = Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerLeft {
+                            device_id,
+                            primary: is_first_touch,
+                            position: Some(position),
+                            kind: PointerKind::Touch(finger_id),
+                        },
+                    };
+                    callback(&self.target, event);
+                },
+                _ => unreachable!(),
+            }
        }
    }

@@ -1355,7 +1466,7 @@ impl EventProcessor {

        if xev.flags & xinput2::XIPointerEmulated == 0 {
            let event = Event::DeviceEvent {
-                device_id: mkdid(xev.deviceid as xinput::DeviceId),
+                device_id: Some(mkdid(xev.deviceid as xinput::DeviceId)),
                event: DeviceEvent::Button { state, button: xev.detail as u32 },
            };
            callback(&self.target, event);
@@ -1369,7 +1480,7 @@ impl EventProcessor {
        // Set the timestamp.
        self.target.xconn.set_timestamp(xev.time as xproto::Timestamp);

-        let did = mkdid(xev.deviceid as xinput::DeviceId);
+        let did = Some(mkdid(xev.deviceid as xinput::DeviceId));

        let mask =
            unsafe { slice::from_raw_parts(xev.valuators.mask, xev.valuators.mask_len as usize) };
@@ -1398,7 +1509,7 @@ impl EventProcessor {
        if let Some(mouse_delta) = mouse_delta.consume() {
            let event = Event::DeviceEvent {
                device_id: did,
-                event: DeviceEvent::MouseMotion { delta: mouse_delta },
+                event: DeviceEvent::PointerMotion { delta: mouse_delta },
            };
            callback(&self.target, event);
        }
@@ -1421,7 +1532,7 @@ impl EventProcessor {
        // Set the timestamp.
        self.target.xconn.set_timestamp(xev.time as xproto::Timestamp);

-        let device_id = mkdid(xev.sourceid as xinput::DeviceId);
+        let device_id = Some(mkdid(xev.sourceid as xinput::DeviceId));
        let keycode = xev.detail as u32;
        if keycode < KEYCODE_OFFSET as u32 {
            return;
@@ -1443,7 +1554,7 @@ impl EventProcessor {
                self.init_device(info.deviceid as xinput::DeviceId);
            } else if 0 != info.flags & (xinput2::XISlaveRemoved | xinput2::XIMasterRemoved) {
                let mut devices = self.devices.borrow_mut();
-                devices.remove(&DeviceId(info.deviceid as xinput::DeviceId));
+                devices.remove(&mkdid(info.deviceid as xinput::DeviceId));
            }
        }
    }
@@ -1695,8 +1806,6 @@ impl EventProcessor {
    ) where
        F: FnMut(&ActiveEventLoop, Event),
    {
-        let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);
-
        // Update modifiers state and emit key events based on which keys are currently pressed.
        let xcb = target.xconn.xcb_connection().get_raw_xcb_connection();

@@ -1719,7 +1828,7 @@ impl EventProcessor {
            let event = key_processor.process_key_event(keycode as u32, state, false);
            let event = Event::WindowEvent {
                window_id,
-                event: WindowEvent::KeyboardInput { device_id, event, is_synthetic: true },
+                event: WindowEvent::KeyboardInput { device_id: None, event, is_synthetic: true },
            };
            callback(target, event);
        }
@@ -1764,15 +1873,15 @@ impl EventProcessor {
    }
 }

-fn is_first_touch(first: &mut Option<u32>, num: &mut u32, id: u32, phase: TouchPhase) -> bool {
+fn is_first_touch(first: &mut Option<u32>, num: &mut u32, id: u32, phase: i32) -> bool {
    match phase {
-        TouchPhase::Started => {
+        xinput2::XI_TouchBegin => {
            if *num == 0 {
                *first = Some(id);
            }
            *num += 1;
        },
-        TouchPhase::Cancelled | TouchPhase::Ended => {
+        xinput2::XI_TouchEnd => {
            if *first == Some(id) {
                *first = None;
            }
--- a/src/platform_impl/linux/x11/ime/mod.rs
+++ b/src/platform_impl/linux/x11/ime/mod.rs
@@ -225,6 +225,16 @@ impl Ime {
        // Create new context supporting IME input.
        let _ = self.create_context(window, allowed);
    }
+
+    pub fn is_ime_allowed(&self, window: ffi::Window) -> bool {
+        if self.is_destroyed() {
+            false
+        } else if let Some(Some(context)) = self.inner.contexts.get(&window) {
+            context.is_allowed()
+        } else {
+            false
+        }
+    }
 }

 impl Drop for Ime {
--- a/src/platform_impl/linux/x11/mod.rs
+++ b/src/platform_impl/linux/x11/mod.rs
@@ -24,19 +24,20 @@ use x11rb::xcb_ffi::ReplyOrIdError;

 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, RequestError};
-use crate::event::{Event, StartCause, WindowEvent};
+use crate::event::{DeviceId, Event, StartCause, WindowEvent};
 use crate::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    OwnedDisplayHandle as RootOwnedDisplayHandle,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::common::xkb::Context;
-use crate::platform_impl::platform::{min_timeout, WindowId};
+use crate::platform_impl::platform::min_timeout;
 use crate::platform_impl::x11::window::Window;
-use crate::platform_impl::{OwnedDisplayHandle, PlatformCustomCursor};
+use crate::platform_impl::PlatformCustomCursor;
 use crate::window::{
    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
-    WindowAttributes,
+    WindowAttributes, WindowId,
 };

 mod activation;
@@ -139,7 +140,7 @@ pub struct ActiveEventLoop {
    windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
    redraw_sender: WakeSender<WindowId>,
    activation_sender: WakeSender<ActivationToken>,
-    event_loop_proxy: EventLoopProxy,
+    event_loop_proxy: CoreEventLoopProxy,
    device_events: Cell<DeviceEvents>,
 }

@@ -306,7 +307,7 @@ impl EventLoop {
                sender: activation_token_sender, // not used again so no clone
                waker: waker.clone(),
            },
-            event_loop_proxy,
+            event_loop_proxy: event_loop_proxy.into(),
            device_events: Default::default(),
        };

@@ -372,15 +373,21 @@ impl EventLoop {
        &self.event_processor.target
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<A: ApplicationHandler>(
+        mut self,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        self.run_on_demand(init_closure)
    }

-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_on_demand<A: ApplicationHandler>(
        &mut self,
-        mut app: A,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
    ) -> Result<(), EventLoopError> {
        self.event_processor.target.clear_exit();
+
+        let mut app = init_closure(&self.event_processor.target);
+
        let exit = loop {
            match self.pump_app_events(None, &mut app) {
                PumpStatus::Exit(0) => {
@@ -428,8 +435,6 @@ impl EventLoop {
        if let Some(code) = self.exit_code() {
            self.loop_running = false;

-            app.exiting(self.window_target());
-
            PumpStatus::Exit(code)
        } else {
            PumpStatus::Continue
@@ -521,13 +526,14 @@ impl EventLoop {

        // Empty activation tokens.
        while let Ok((window_id, serial)) = self.activation_receiver.try_recv() {
-            let token = self.event_processor.with_window(window_id.0 as xproto::Window, |window| {
-                window.generate_activation_token()
-            });
+            let token = self
+                .event_processor
+                .with_window(window_id.into_raw() as xproto::Window, |window| {
+                    window.generate_activation_token()
+                });

            match token {
                Some(Ok(token)) => {
-                    let window_id = crate::window::WindowId(window_id);
                    let event = WindowEvent::ActivationTokenDone {
                        serial,
                        token: crate::window::ActivationToken::_new(token),
@@ -555,7 +561,6 @@ impl EventLoop {
            }

            for window_id in windows {
-                let window_id = crate::window::WindowId(window_id);
                app.window_event(
                    &self.event_processor.target,
                    window_id,
@@ -574,12 +579,9 @@ impl EventLoop {
        while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
            let mut xev = unsafe { xev.assume_init() };
            self.event_processor.process_event(&mut xev, |window_target, event: Event| {
-                if let Event::WindowEvent {
-                    window_id: crate::window::WindowId(wid),
-                    event: WindowEvent::RedrawRequested,
-                } = event
+                if let Event::WindowEvent { window_id, event: WindowEvent::RedrawRequested } = event
                {
-                    window_target.redraw_sender.send(wid);
+                    window_target.redraw_sender.send(window_id);
                } else {
                    match event {
                        Event::WindowEvent { window_id, event } => {
@@ -650,21 +652,6 @@ impl ActiveEventLoop {
            .expect_then_ignore_error("Failed to update device event filter");
    }

-    #[cfg(feature = "rwh_06")]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        let display_handle = rwh_06::XlibDisplayHandle::new(
-            // SAFETY: display will never be null
-            Some(
-                std::ptr::NonNull::new(self.xconn.display as *mut _)
-                    .expect("X11 display should never be null"),
-            ),
-            self.xconn.default_screen_index() as c_int,
-        );
-        Ok(display_handle.into())
-    }
-
    pub(crate) fn clear_exit(&self) {
        self.exit.set(None)
    }
@@ -679,12 +666,8 @@ impl ActiveEventLoop {
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> crate::event_loop::EventLoopProxy {
-        crate::event_loop::EventLoopProxy {
-            event_loop_proxy: crate::platform_impl::EventLoopProxy::X(
-                self.event_loop_proxy.clone(),
-            ),
-        }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        self.event_loop_proxy.clone()
    }

    fn create_window(
@@ -746,28 +729,18 @@ impl RootActiveEventLoop for ActiveEventLoop {
        self.exit.get().is_some()
    }

-    fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
-        let handle = OwnedDisplayHandle::X(self.x_connection().clone());
-        RootOwnedDisplayHandle { platform: handle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(self.x_connection().clone())
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
-        let raw = self.raw_display_handle_rwh_06()?;
-        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
-    }
-}
-
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        self.ping.ping();
+        self.xconn.display_handle()
    }
 }

@@ -793,14 +766,14 @@ impl<'a> DeviceInfo<'a> {
    }
 }

-impl<'a> Drop for DeviceInfo<'a> {
+impl Drop for DeviceInfo<'_> {
    fn drop(&mut self) {
        assert!(!self.info.is_null());
        unsafe { (self.xconn.xinput2.XIFreeDeviceInfo)(self.info as *mut _) };
    }
 }

-impl<'a> Deref for DeviceInfo<'a> {
+impl Deref for DeviceInfo<'_> {
    type Target = [ffi::XIDeviceInfo];

    fn deref(&self) -> &Self::Target {
@@ -808,37 +781,29 @@ impl<'a> Deref for DeviceInfo<'a> {
    }
 }

-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId(xinput::DeviceId);
-
-impl DeviceId {
-    #[allow(unused)]
-    pub const fn dummy() -> Self {
-        DeviceId(0)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId(u32);
-
-impl FingerId {
-    #[allow(unused)]
-    pub const fn dummy() -> Self {
-        FingerId(0)
-    }
-}
-
 #[derive(Clone)]
 pub struct EventLoopProxy {
    ping: Ping,
 }

+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.ping.ping();
+    }
+}
+
 impl EventLoopProxy {
    fn new(ping: Ping) -> Self {
        Self { ping }
    }
 }

+impl From<EventLoopProxy> for CoreEventLoopProxy {
+    fn from(value: EventLoopProxy) -> Self {
+        CoreEventLoopProxy::new(Arc::new(value))
+    }
+}
+
 /// Generic sum error type for X11 errors.
 #[derive(Debug)]
 pub enum X11Error {
@@ -882,24 +847,24 @@ pub enum X11Error {
 impl fmt::Display for X11Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            X11Error::Xlib(e) => write!(f, "Xlib error: {}", e),
-            X11Error::Connect(e) => write!(f, "X11 connection error: {}", e),
-            X11Error::Connection(e) => write!(f, "X11 connection error: {}", e),
-            X11Error::XidsExhausted(e) => write!(f, "XID range exhausted: {}", e),
-            X11Error::GetProperty(e) => write!(f, "Failed to get X property {}", e),
-            X11Error::X11(e) => write!(f, "X11 error: {:?}", e),
-            X11Error::UnexpectedNull(s) => write!(f, "Xlib function returned null: {}", s),
+            X11Error::Xlib(e) => write!(f, "Xlib error: {e}"),
+            X11Error::Connect(e) => write!(f, "X11 connection error: {e}"),
+            X11Error::Connection(e) => write!(f, "X11 connection error: {e}"),
+            X11Error::XidsExhausted(e) => write!(f, "XID range exhausted: {e}"),
+            X11Error::GetProperty(e) => write!(f, "Failed to get X property {e}"),
+            X11Error::X11(e) => write!(f, "X11 error: {e:?}"),
+            X11Error::UnexpectedNull(s) => write!(f, "Xlib function returned null: {s}"),
            X11Error::InvalidActivationToken(s) => write!(
                f,
                "Invalid activation token: {}",
                std::str::from_utf8(s).unwrap_or("<invalid utf8>")
            ),
-            X11Error::MissingExtension(s) => write!(f, "Missing X11 extension: {}", s),
+            X11Error::MissingExtension(s) => write!(f, "Missing X11 extension: {s}"),
            X11Error::NoSuchVisual(visualid) => {
-                write!(f, "Could not find a matching X11 visual for ID `{:x}`", visualid)
+                write!(f, "Could not find a matching X11 visual for ID `{visualid:x}`")
            },
            X11Error::XsettingsParse(err) => {
-                write!(f, "Failed to parse xsettings: {:?}", err)
+                write!(f, "Failed to parse xsettings: {err:?}")
            },
            X11Error::NoArgb32Format => {
                f.write_str("winit only supports X11 displays with ARGB32 picture formats")
@@ -993,21 +958,17 @@ trait CookieResultExt {
    fn expect_then_ignore_error(self, msg: &str);
 }

-impl<'a, E: fmt::Debug> CookieResultExt for Result<VoidCookie<'a>, E> {
+impl<E: fmt::Debug> CookieResultExt for Result<VoidCookie<'_>, E> {
    fn expect_then_ignore_error(self, msg: &str) {
        self.expect(msg).ignore_error()
    }
 }

 fn mkwid(w: xproto::Window) -> crate::window::WindowId {
-    crate::window::WindowId(crate::platform_impl::platform::WindowId(w as _))
+    crate::window::WindowId::from_raw(w as _)
 }
-fn mkdid(w: xinput::DeviceId) -> crate::event::DeviceId {
-    crate::event::DeviceId(crate::platform_impl::DeviceId::X(DeviceId(w)))
-}
-
-fn mkfid(w: u32) -> crate::event::FingerId {
-    crate::event::FingerId(crate::platform_impl::FingerId::X(FingerId(w)))
+fn mkdid(w: xinput::DeviceId) -> DeviceId {
+    DeviceId::from_raw(w as i64)
 }

 #[derive(Debug)]
--- a/src/platform_impl/linux/x11/monitor.rs
+++ b/src/platform_impl/linux/x11/monitor.rs
@@ -280,7 +280,7 @@ impl XConnection {
        let info = self
            .xcb_connection()
            .extension_information(randr::X11_EXTENSION_NAME)?
-            .ok_or_else(|| X11Error::MissingExtension(randr::X11_EXTENSION_NAME))?;
+            .ok_or(X11Error::MissingExtension(randr::X11_EXTENSION_NAME))?;

        // Select input data.
        let event_mask =
--- a/src/platform_impl/linux/x11/util/geometry.rs
+++ b/src/platform_impl/linux/x11/util/geometry.rs
@@ -67,15 +67,20 @@ pub struct FrameExtentsHeuristic {
 }

 impl FrameExtentsHeuristic {
-    pub fn inner_pos_to_outer(&self, x: i32, y: i32) -> (i32, i32) {
+    pub fn surface_position(&self) -> (i32, i32) {
        use self::FrameExtentsHeuristicPath::*;
        if self.heuristic_path != UnsupportedBordered {
-            (x - self.frame_extents.left as i32, y - self.frame_extents.top as i32)
+            (self.frame_extents.left as i32, self.frame_extents.top as i32)
        } else {
-            (x, y)
+            (0, 0)
        }
    }

+    pub fn inner_pos_to_outer(&self, x: i32, y: i32) -> (i32, i32) {
+        let (left, top) = self.surface_position();
+        (x - left, y - top)
+    }
+
    pub fn surface_size_to_outer(&self, width: u32, height: u32) -> (u32, u32) {
        (
            width.saturating_add(
--- a/src/platform_impl/linux/x11/util/input.rs
+++ b/src/platform_impl/linux/x11/util/input.rs
@@ -6,7 +6,6 @@ use x11rb::protocol::xkb;
 use super::*;

 pub const VIRTUAL_CORE_POINTER: u16 = 2;
-pub const VIRTUAL_CORE_KEYBOARD: u16 = 3;

 // A base buffer size of 1kB uses a negligible amount of RAM while preventing us from having to
 // re-allocate (and make another round-trip) in the *vast* majority of cases.
--- a/src/platform_impl/linux/x11/util/memory.rs
+++ b/src/platform_impl/linux/x11/util/memory.rs
@@ -19,7 +19,7 @@ impl<'a, T> XSmartPointer<'a, T> {
    }
 }

-impl<'a, T> Deref for XSmartPointer<'a, T> {
+impl<T> Deref for XSmartPointer<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
@@ -27,13 +27,13 @@ impl<'a, T> Deref for XSmartPointer<'a, T> {
    }
 }

-impl<'a, T> DerefMut for XSmartPointer<'a, T> {
+impl<T> DerefMut for XSmartPointer<'_, T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { &mut *self.ptr }
    }
 }

-impl<'a, T> Drop for XSmartPointer<'a, T> {
+impl<T> Drop for XSmartPointer<'_, T> {
    fn drop(&mut self) {
        unsafe {
            (self.xconn.xlib.XFree)(self.ptr as *mut _);
--- a/src/platform_impl/linux/x11/window.rs
+++ b/src/platform_impl/linux/x11/window.rs
@@ -18,10 +18,10 @@ use x11rb::protocol::{randr, xinput};

 use super::util::{self, SelectedCursor};
 use super::{
-    ffi, ActiveEventLoop, CookieResultExt, ImeRequest, ImeSender, VoidCookie, WindowId, XConnection,
+    ffi, ActiveEventLoop, CookieResultExt, ImeRequest, ImeSender, VoidCookie, XConnection,
 };
 use crate::cursor::{Cursor, CustomCursor as RootCustomCursor};
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Event, SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
@@ -36,7 +36,7 @@ use crate::platform_impl::{
 };
 use crate::window::{
    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
-    WindowAttributes, WindowButtons, WindowLevel,
+    WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };

 pub(crate) struct Window(Arc<UnownedWindow>);
@@ -62,8 +62,8 @@ impl Window {
 }

 impl CoreWindow for Window {
-    fn id(&self) -> crate::window::WindowId {
-        crate::window::WindowId(self.0.id())
+    fn id(&self) -> WindowId {
+        self.0.id()
    }

    fn scale_factor(&self) -> f64 {
@@ -82,8 +82,8 @@ impl CoreWindow for Window {
        common::xkb::reset_dead_keys();
    }

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        self.0.inner_position()
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        self.0.surface_position()
    }

    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
@@ -106,6 +106,10 @@ impl CoreWindow for Window {
        self.0.outer_size()
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        self.0.safe_area()
+    }
+
    fn set_min_surface_size(&self, min_size: Option<Size>) {
        self.0.set_min_surface_size(min_size)
    }
@@ -294,18 +298,15 @@ impl CoreWindow for Window {
            .map(|inner| crate::monitor::MonitorHandle { inner })
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.0.raw_display_handle_rwh_06()?;
@@ -313,7 +314,6 @@ impl rwh_06::HasDisplayHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.0.raw_window_handle_rwh_06()?;
@@ -331,7 +331,9 @@ impl Drop for Window {
            window.set_fullscreen(None);
        }

-        if let Ok(c) = xconn.xcb_connection().destroy_window(window.id().0 as xproto::Window) {
+        if let Ok(c) =
+            xconn.xcb_connection().destroy_window(window.id().into_raw() as xproto::Window)
+        {
            c.ignore_error();
        }
    }
@@ -441,15 +443,26 @@ impl UnownedWindow {
    ) -> Result<UnownedWindow, RequestError> {
        let xconn = &event_loop.xconn;
        let atoms = xconn.atoms();
-        #[cfg(feature = "rwh_06")]
+
+        let screen_id = match window_attrs.platform_specific.x11.screen_id {
+            Some(id) => id,
+            None => xconn.default_screen_index() as c_int,
+        };
+
+        let screen = {
+            let screen_id_usize = usize::try_from(screen_id)
+                .map_err(|_| NotSupportedError::new("screen id must be non-negative"))?;
+            xconn.xcb_connection().setup().roots.get(screen_id_usize).ok_or(
+                NotSupportedError::new("requested screen id not present in server's response"),
+            )?
+        };
+
        let root = match window_attrs.parent_window.as_ref().map(|handle| handle.0) {
            Some(rwh_06::RawWindowHandle::Xlib(handle)) => handle.window as xproto::Window,
            Some(rwh_06::RawWindowHandle::Xcb(handle)) => handle.window.get(),
            Some(raw) => unreachable!("Invalid raw window handle {raw:?} on X11"),
-            None => event_loop.root,
+            None => screen.root,
        };
-        #[cfg(not(feature = "rwh_06"))]
-        let root = event_loop.root;

        let mut monitors = leap!(xconn.available_monitors());
        let guessed_monitor = if monitors.is_empty() {
@@ -504,18 +517,10 @@ impl UnownedWindow {
            dimensions
        };

-        let screen_id = match window_attrs.platform_specific.x11.screen_id {
-            Some(id) => id,
-            None => xconn.default_screen_index() as c_int,
-        };
-
-        // An iterator over all of the visuals combined with their depths.
-        let mut all_visuals = xconn
-            .xcb_connection()
-            .setup()
-            .roots
+        // An iterator over the visuals matching screen id combined with their depths.
+        let mut all_visuals = screen
+            .allowed_depths
            .iter()
-            .flat_map(|root| &root.allowed_depths)
            .flat_map(|depth| depth.visuals.iter().map(move |visual| (visual, depth.depth)));

        // creating
@@ -804,6 +809,20 @@ impl UnownedWindow {
                leap!(result).ignore_error();
            }

+            // Select XInput2 events
+            let mask = xinput::XIEventMask::MOTION
+                | xinput::XIEventMask::BUTTON_PRESS
+                | xinput::XIEventMask::BUTTON_RELEASE
+                | xinput::XIEventMask::ENTER
+                | xinput::XIEventMask::LEAVE
+                | xinput::XIEventMask::FOCUS_IN
+                | xinput::XIEventMask::FOCUS_OUT
+                | xinput::XIEventMask::TOUCH_BEGIN
+                | xinput::XIEventMask::TOUCH_UPDATE
+                | xinput::XIEventMask::TOUCH_END;
+            leap!(xconn.select_xinput_events(window.xwindow, super::ALL_MASTER_DEVICES, mask))
+                .ignore_error();
+
            // Set visibility (map window)
            if window_attrs.visible {
                leap!(xconn.xcb_connection().map_window(window.xwindow)).ignore_error();
@@ -827,20 +846,6 @@ impl UnownedWindow {
                }
            }

-            // Select XInput2 events
-            let mask = xinput::XIEventMask::MOTION
-                | xinput::XIEventMask::BUTTON_PRESS
-                | xinput::XIEventMask::BUTTON_RELEASE
-                | xinput::XIEventMask::ENTER
-                | xinput::XIEventMask::LEAVE
-                | xinput::XIEventMask::FOCUS_IN
-                | xinput::XIEventMask::FOCUS_OUT
-                | xinput::XIEventMask::TOUCH_BEGIN
-                | xinput::XIEventMask::TOUCH_UPDATE
-                | xinput::XIEventMask::TOUCH_END;
-            leap!(xconn.select_xinput_events(window.xwindow, super::ALL_MASTER_DEVICES, mask))
-                .ignore_error();
-
            // Try to create input context for the window.
            if let Some(ime) = event_loop.ime.as_ref() {
                ime.borrow_mut()
@@ -1220,11 +1225,10 @@ impl UnownedWindow {
                &self.shared_state_lock(),
            );

-            let window_id = crate::window::WindowId(self.id());
            let old_surface_size = PhysicalSize::new(width, height);
            let surface_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
            callback(Event::WindowEvent {
-                window_id,
+                window_id: self.id(),
                event: WindowEvent::ScaleFactorChanged {
                    scale_factor: new_monitor.scale_factor,
                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&surface_size)),
@@ -1508,7 +1512,7 @@ impl UnownedWindow {
        }
    }

-    pub(crate) fn inner_position_physical(&self) -> (i32, i32) {
+    fn inner_position_physical(&self) -> (i32, i32) {
        // This should be okay to unwrap since the only error XTranslateCoordinates can return
        // is BadWindow, and if the window handle is bad we have bigger problems.
        self.xconn
@@ -1518,8 +1522,14 @@ impl UnownedWindow {
    }

    #[inline]
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        Ok(self.inner_position_physical().into())
+    pub fn surface_position(&self) -> PhysicalPosition<i32> {
+        let extents = self.shared_state_lock().frame_extents.clone();
+        if let Some(extents) = extents {
+            extents.surface_position().into()
+        } else {
+            self.update_cached_frame_extents();
+            self.surface_position()
+        }
    }

    pub(crate) fn set_position_inner(
@@ -1582,6 +1592,10 @@ impl UnownedWindow {
        }
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        PhysicalInsets::new(0, 0, 0, 0)
+    }
+
    pub(crate) fn request_surface_size_physical(&self, width: u32, height: u32) {
        self.xconn
            .xcb_connection()
@@ -1989,7 +2003,7 @@ impl UnownedWindow {
            .query_pointer(self.xwindow, util::VIRTUAL_CORE_POINTER)
            .map_err(|err| os_error!(err))?;

-        let window_position = self.inner_position()?;
+        let window_position = self.inner_position_physical();

        let atoms = self.xconn.atoms();
        let message = atoms[_NET_WM_MOVERESIZE];
@@ -2016,8 +2030,8 @@ impl UnownedWindow {
                        | xproto::EventMask::SUBSTRUCTURE_NOTIFY,
                ),
                [
-                    (window_position.x + xinput_fp1616_to_float(pointer.win_x) as i32) as u32,
-                    (window_position.y + xinput_fp1616_to_float(pointer.win_y) as i32) as u32,
+                    (window_position.0 + xinput_fp1616_to_float(pointer.win_x) as i32) as u32,
+                    (window_position.1 + xinput_fp1616_to_float(pointer.win_y) as i32) as u32,
                    action.try_into().unwrap(),
                    1, // Button 1
                    1,
@@ -2031,12 +2045,19 @@ impl UnownedWindow {
    }

    #[inline]
-    pub fn set_ime_cursor_area(&self, spot: Position, _size: Size) {
-        let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
+    pub fn set_ime_cursor_area(&self, spot: Position, size: Size) {
+        let PhysicalPosition { x, y } = spot.to_physical::<i16>(self.scale_factor());
+        let PhysicalSize { width, height } = size.to_physical::<i16>(self.scale_factor());
+        // We only currently support reporting a caret position via XIM.
+        // No IM servers currently process preedit area information from XIM clients
+        // and it is unclear this is even part of the standard protocol.
+        // Fcitx and iBus both assume that the position reported is at the insertion
+        // caret, and by default will place the candidate window under and to the
+        // right of the reported point.
        let _ = self.ime_sender.lock().unwrap().send(ImeRequest::Position(
            self.xwindow as ffi::Window,
-            x,
-            y,
+            x.saturating_add(width),
+            y.saturating_add(height),
        ));
    }

@@ -2134,7 +2155,7 @@ impl UnownedWindow {

    #[inline]
    pub fn id(&self) -> WindowId {
-        WindowId(self.xwindow as _)
+        WindowId::from_raw(self.xwindow as _)
    }

    pub(super) fn sync_counter_id(&self) -> Option<NonZeroU32> {
@@ -2143,7 +2164,7 @@ impl UnownedWindow {

    #[inline]
    pub fn request_redraw(&self) {
-        self.redraw_sender.send(WindowId(self.xwindow as _));
+        self.redraw_sender.send(WindowId::from_raw(self.xwindow as _));
    }

    #[inline]
@@ -2151,7 +2172,6 @@ impl UnownedWindow {
        // TODO timer
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
        let mut window_handle = rwh_06::XlibWindowHandle::new(self.xlib_window());
@@ -2159,7 +2179,6 @@ impl UnownedWindow {
        Ok(window_handle.into())
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub fn raw_display_handle_rwh_06(
        &self,
--- a/src/platform_impl/linux/x11/xdisplay.rs
+++ b/src/platform_impl/linux/x11/xdisplay.rs
@@ -1,9 +1,11 @@
 use std::collections::HashMap;
 use std::error::Error;
+use std::ffi::c_int;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Arc, Mutex, RwLock, RwLockReadGuard};
 use std::{fmt, ptr};

+use rwh_06::HasDisplayHandle;
 use x11rb::connection::Connection;
 use x11rb::protocol::randr::ConnectionExt as _;
 use x11rb::protocol::render;
@@ -62,6 +64,13 @@ pub struct XConnection {
    pub cursor_cache: Mutex<HashMap<Option<CursorIcon>, xproto::Cursor>>,
 }

+impl HasDisplayHandle for XConnection {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_display_handle()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
+}
+
 unsafe impl Send for XConnection {}
 unsafe impl Sync for XConnection {}

@@ -155,7 +164,7 @@ impl XConnection {
    fn new_xsettings_screen(xcb: &XCBConnection, default_screen: usize) -> Option<xproto::Atom> {
        // Fetch the _XSETTINGS_S[screen number] atom.
        let xsettings_screen = xcb
-            .intern_atom(false, format!("_XSETTINGS_S{}", default_screen).as_bytes())
+            .intern_atom(false, format!("_XSETTINGS_S{default_screen}").as_bytes())
            .ok()?
            .reply()
            .ok()?
@@ -284,6 +293,19 @@ impl XConnection {

        self.xcb_connection().setup().image_byte_order != endian
    }
+
+    pub fn raw_display_handle(&self) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        let display_handle = rwh_06::XlibDisplayHandle::new(
+            // SAFETY: display will never be null
+            Some(
+                std::ptr::NonNull::new(self.display as *mut _)
+                    .expect("X11 display should never be null"),
+            ),
+            self.default_screen_index() as c_int,
+        );
+
+        Ok(display_handle.into())
+    }
 }

 impl fmt::Debug for XConnection {
--- a/src/platform_impl/mod.rs
+++ b/src/platform_impl/mod.rs
@@ -22,6 +22,7 @@ use self::apple as platform;
 use self::linux as platform;
 #[cfg(orbital_platform)]
 use self::orbital as platform;
+#[allow(unused_imports)]
 pub use self::platform::*;
 #[cfg(web_platform)]
 use self::web as platform;
--- a/src/platform_impl/orbital/event_loop.rs
+++ b/src/platform_impl/orbital/event_loop.rs
@@ -12,21 +12,24 @@ use orbclient::{
 use smol_str::SmolStr;

 use super::{
-    DeviceId, KeyEventExtra, MonitorHandle, PlatformSpecificEventLoopAttributes, RedoxSocket,
-    TimeSocket, WindowId, WindowProperties,
+    KeyEventExtra, MonitorHandle, PlatformSpecificEventLoopAttributes, RedoxSocket, TimeSocket,
+    WindowProperties,
 };
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, NotSupportedError, RequestError};
 use crate::event::{self, Ime, Modifiers, StartCause};
-use crate::event_loop::{self, ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
+use crate::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
+    OwnedDisplayHandle as CoreOwnedDisplayHandle,
+};
 use crate::keyboard::{
    Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
    PhysicalKey,
 };
 use crate::platform_impl::Window;
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
-    WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow, WindowId,
 };

 fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
@@ -287,8 +290,7 @@ impl EventLoop {
        let event_socket =
            Arc::new(RedoxSocket::event().map_err(|error| os_error!(format!("{error}")))?);

-        let wake_socket =
-            Arc::new(TimeSocket::open().map_err(|error| os_error!(format!("{error}")))?);
+        let wake_socket = TimeSocket::open().map_err(|error| os_error!(format!("{error}")))?;

        event_socket
            .write(&syscall::Event {
@@ -307,8 +309,7 @@ impl EventLoop {
                redraws: Arc::new(Mutex::new(VecDeque::new())),
                destroys: Arc::new(Mutex::new(VecDeque::new())),
                event_socket,
-                wake_socket,
-                user_events_sender,
+                event_loop_proxy: Arc::new(EventLoopProxy { wake_socket, user_events_sender }),
            },
            user_events_receiver,
        })
@@ -362,9 +363,8 @@ impl EventLoop {
                    key_without_modifiers = logical_key.clone();
                }

-                let window_id = RootWindowId(window_id);
                let event = event::WindowEvent::KeyboardInput {
-                    device_id: event::DeviceId(DeviceId),
+                    device_id: None,
                    event: event::KeyEvent {
                        logical_key,
                        physical_key,
@@ -394,81 +394,63 @@ impl EventLoop {
            EventOption::TextInput(TextInputEvent { character }) => {
                app.window_event(
                    window_target,
-                    RootWindowId(window_id),
+                    window_id,
                    event::WindowEvent::Ime(Ime::Preedit("".into(), None)),
                );
                app.window_event(
                    window_target,
-                    RootWindowId(window_id),
+                    window_id,
                    event::WindowEvent::Ime(Ime::Commit(character.into())),
                );
            },
            EventOption::Mouse(MouseEvent { x, y }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::CursorMoved {
-                        device_id: event::DeviceId(DeviceId),
-                        position: (x, y).into(),
-                    },
-                );
+                app.window_event(window_target, window_id, event::WindowEvent::PointerMoved {
+                    device_id: None,
+                    primary: true,
+                    position: (x, y).into(),
+                    source: event::PointerSource::Mouse,
+                });
            },
            EventOption::MouseRelative(MouseRelativeEvent { dx, dy }) => {
-                app.device_event(
-                    window_target,
-                    event::DeviceId(DeviceId),
-                    event::DeviceEvent::MouseMotion { delta: (dx as f64, dy as f64) },
-                );
+                app.device_event(window_target, None, event::DeviceEvent::PointerMotion {
+                    delta: (dx as f64, dy as f64),
+                });
            },
            EventOption::Button(ButtonEvent { left, middle, right }) => {
                while let Some((button, state)) = event_state.mouse(left, middle, right) {
-                    app.window_event(
-                        window_target,
-                        RootWindowId(window_id),
-                        event::WindowEvent::MouseInput {
-                            device_id: event::DeviceId(DeviceId),
-                            state,
-                            button,
-                        },
-                    );
+                    app.window_event(window_target, window_id, event::WindowEvent::PointerButton {
+                        device_id: None,
+                        primary: true,
+                        state,
+                        position: dpi::PhysicalPosition::default(),
+                        button: button.into(),
+                    });
                }
            },
            EventOption::Scroll(ScrollEvent { x, y }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::MouseWheel {
-                        device_id: event::DeviceId(DeviceId),
-                        delta: event::MouseScrollDelta::LineDelta(x as f32, y as f32),
-                        phase: event::TouchPhase::Moved,
-                    },
-                );
+                app.window_event(window_target, window_id, event::WindowEvent::MouseWheel {
+                    device_id: None,
+                    delta: event::MouseScrollDelta::LineDelta(x as f32, y as f32),
+                    phase: event::TouchPhase::Moved,
+                });
            },
            EventOption::Quit(QuitEvent {}) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::CloseRequested,
-                );
+                app.window_event(window_target, window_id, event::WindowEvent::CloseRequested);
            },
            EventOption::Focus(FocusEvent { focused }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Focused(focused),
-                );
+                app.window_event(window_target, window_id, event::WindowEvent::Focused(focused));
            },
            EventOption::Move(MoveEvent { x, y }) => {
                app.window_event(
                    window_target,
-                    RootWindowId(window_id),
+                    window_id,
                    event::WindowEvent::Moved((x, y).into()),
                );
            },
            EventOption::Resize(ResizeEvent { width, height }) => {
                app.window_event(
                    window_target,
-                    RootWindowId(window_id),
+                    window_id,
                    event::WindowEvent::SurfaceResized((width, height).into()),
                );

@@ -478,12 +460,22 @@ impl EventLoop {
            // TODO: Screen, Clipboard, Drop
            EventOption::Hover(HoverEvent { entered }) => {
                let event = if entered {
-                    event::WindowEvent::CursorEntered { device_id: event::DeviceId(DeviceId) }
+                    event::WindowEvent::PointerEntered {
+                        device_id: None,
+                        primary: true,
+                        position: dpi::PhysicalPosition::default(),
+                        kind: event::PointerKind::Mouse,
+                    }
                } else {
-                    event::WindowEvent::CursorLeft { device_id: event::DeviceId(DeviceId) }
+                    event::WindowEvent::PointerLeft {
+                        device_id: None,
+                        primary: true,
+                        position: None,
+                        kind: event::PointerKind::Mouse,
+                    }
                };

-                app.window_event(window_target, RootWindowId(window_id), event);
+                app.window_event(window_target, window_id, event);
            },
            other => {
                tracing::warn!("unhandled event: {:?}", other);
@@ -491,7 +483,11 @@ impl EventLoop {
        }
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, mut app: A) -> Result<(), EventLoopError> {
+    pub fn run<A: ApplicationHandler>(
+        mut self,
+        init_closure: impl FnOnce(&dyn RootActiveEventLoop) -> A,
+    ) -> Result<(), EventLoopError> {
+        let mut app = init_closure(&self.window_target);
        let mut start_cause = StartCause::Init;
        loop {
            app.new_events(&self.window_target, start_cause);
@@ -505,7 +501,7 @@ impl EventLoop {
                let mut creates = self.window_target.creates.lock().unwrap();
                creates.pop_front()
            } {
-                let window_id = WindowId { fd: window.fd as u64 };
+                let window_id = WindowId::from_raw(window.fd);

                let mut buf: [u8; 4096] = [0; 4096];
                let path = window.fpath(&mut buf).expect("failed to read properties");
@@ -513,8 +509,6 @@ impl EventLoop {

                self.windows.push((window, EventState::default()));

-                let window_id = RootWindowId(window_id);
-
                // Send resize event on create to indicate first size.
                let event = event::WindowEvent::SurfaceResized((properties.w, properties.h).into());
                app.window_event(&self.window_target, window_id, event);
@@ -529,16 +523,16 @@ impl EventLoop {
                let mut destroys = self.window_target.destroys.lock().unwrap();
                destroys.pop_front()
            } {
-                let window_id = RootWindowId(destroy_id);
-                app.window_event(&self.window_target, window_id, event::WindowEvent::Destroyed);
-                self.windows.retain(|(window, _event_state)| window.fd as u64 != destroy_id.fd);
+                app.window_event(&self.window_target, destroy_id, event::WindowEvent::Destroyed);
+                self.windows
+                    .retain(|(window, _event_state)| WindowId::from_raw(window.fd) != destroy_id);
            }

            // Handle window events.
            let mut i = 0;
            // While loop is used here because the same window may be processed more than once.
            while let Some((window, event_state)) = self.windows.get_mut(i) {
-                let window_id = WindowId { fd: window.fd as u64 };
+                let window_id = WindowId::from_raw(window.fd);

                let mut event_buf = [0u8; 16 * mem::size_of::<orbclient::Event>()];
                let count =
@@ -596,7 +590,7 @@ impl EventLoop {
            } {
                app.window_event(
                    &self.window_target,
-                    RootWindowId(window_id),
+                    window_id,
                    event::WindowEvent::RedrawRequested,
                );
            }
@@ -664,8 +658,6 @@ impl EventLoop {
            }
        }

-        app.exiting(&self.window_target);
-
        Ok(())
    }

@@ -676,11 +668,11 @@ impl EventLoop {

 pub struct EventLoopProxy {
    user_events_sender: mpsc::SyncSender<()>,
-    wake_socket: Arc<TimeSocket>,
+    pub(super) wake_socket: TimeSocket,
 }

-impl EventLoopProxy {
-    pub fn wake_up(&self) {
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
        // When we fail to send the event it means that we haven't woken up to read the previous
        // event.
        if self.user_events_sender.try_send(()).is_ok() {
@@ -689,15 +681,6 @@ impl EventLoopProxy {
    }
 }

-impl Clone for EventLoopProxy {
-    fn clone(&self) -> Self {
-        Self {
-            user_events_sender: self.user_events_sender.clone(),
-            wake_socket: self.wake_socket.clone(),
-        }
-    }
-}
-
 impl Unpin for EventLoopProxy {}

 pub struct ActiveEventLoop {
@@ -707,18 +690,12 @@ pub struct ActiveEventLoop {
    pub(super) redraws: Arc<Mutex<VecDeque<WindowId>>>,
    pub(super) destroys: Arc<Mutex<VecDeque<WindowId>>>,
    pub(super) event_socket: Arc<RedoxSocket>,
-    pub(super) wake_socket: Arc<TimeSocket>,
-    user_events_sender: mpsc::SyncSender<()>,
+    pub(super) event_loop_proxy: Arc<EventLoopProxy>,
 }

 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> event_loop::EventLoopProxy {
-        event_loop::EventLoopProxy {
-            event_loop_proxy: EventLoopProxy {
-                user_events_sender: self.user_events_sender.clone(),
-                wake_socket: self.wake_socket.clone(),
-            },
-        }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        CoreEventLoopProxy::new(self.event_loop_proxy.clone())
    }

    fn create_window(
@@ -767,17 +744,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
        self.exit.get()
    }

-    fn owned_display_handle(&self) -> event_loop::OwnedDisplayHandle {
-        event_loop::OwnedDisplayHandle { platform: OwnedDisplayHandle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(Arc::new(OwnedDisplayHandle))
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::RawDisplayHandle::Orbital(rwh_06::OrbitalDisplayHandle::new());
@@ -785,15 +760,12 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    }
 }

-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone)]
 pub(crate) struct OwnedDisplayHandle;

-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::OrbitalDisplayHandle::new().into())
+impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::RawDisplayHandle::Orbital(rwh_06::OrbitalDisplayHandle::new());
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
    }
 }
--- a/src/platform_impl/orbital/mod.rs
+++ b/src/platform_impl/orbital/mod.rs
@@ -5,7 +5,7 @@ use std::{fmt, str};

 use smol_str::SmolStr;

-pub(crate) use self::event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle};
+pub(crate) use self::event_loop::{ActiveEventLoop, EventLoop};
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::keyboard::Key;
 mod event_loop;
@@ -99,47 +99,6 @@ impl TimeSocket {
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}

-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct WindowId {
-    fd: u64,
-}
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        WindowId { fd: u64::MAX }
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(id: WindowId) -> Self {
-        id.fd
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(fd: u64) -> Self {
-        Self { fd }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DeviceId;
-
-impl DeviceId {
-    pub const fn dummy() -> Self {
-        DeviceId
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct FingerId;
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId
-    }
-}
-
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct PlatformSpecificWindowAttributes;

@@ -166,7 +125,7 @@ impl<'a> WindowProperties<'a> {
    }
 }

-impl<'a> fmt::Display for WindowProperties<'a> {
+impl fmt::Display for WindowProperties<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
--- a/src/platform_impl/orbital/window.rs
+++ b/src/platform_impl/orbital/window.rs
@@ -1,12 +1,13 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};

-use super::{ActiveEventLoop, MonitorHandle, RedoxSocket, TimeSocket, WindowId, WindowProperties};
+use super::event_loop::EventLoopProxy;
+use super::{ActiveEventLoop, MonitorHandle, RedoxSocket, WindowProperties};
 use crate::cursor::Cursor;
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::window::{self, Fullscreen, ImePurpose, Window as CoreWindow, WindowId as CoreWindowId};
+use crate::window::{self, Fullscreen, ImePurpose, Window as CoreWindow, WindowId};

 // These values match the values uses in the `window_new` function in orbital:
 // https://gitlab.redox-os.org/redox-os/orbital/-/blob/master/src/scheme.rs
@@ -23,7 +24,7 @@ pub struct Window {
    window_socket: Arc<RedoxSocket>,
    redraws: Arc<Mutex<VecDeque<WindowId>>>,
    destroys: Arc<Mutex<VecDeque<WindowId>>>,
-    wake_socket: Arc<TimeSocket>,
+    event_loop_proxy: Arc<EventLoopProxy>,
 }

 impl Window {
@@ -113,13 +114,13 @@ impl Window {
            creates.push_back(window_socket.clone());
        }

-        el.wake_socket.wake().unwrap();
+        el.event_loop_proxy.wake_socket.wake().unwrap();

        Ok(Self {
            window_socket,
            redraws: el.redraws.clone(),
            destroys: el.destroys.clone(),
-            wake_socket: el.wake_socket.clone(),
+            event_loop_proxy: el.event_loop_proxy.clone(),
        })
    }

@@ -137,7 +138,6 @@ impl Window {
        Ok(())
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
        let handle = rwh_06::OrbitalWindowHandle::new({
@@ -147,7 +147,6 @@ impl Window {
        Ok(rwh_06::RawWindowHandle::Orbital(handle))
    }

-    #[cfg(feature = "rwh_06")]
    #[inline]
    fn raw_display_handle_rwh_06(&self) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
        Ok(rwh_06::RawDisplayHandle::Orbital(rwh_06::OrbitalDisplayHandle::new()))
@@ -155,8 +154,8 @@ impl Window {
 }

 impl CoreWindow for Window {
-    fn id(&self) -> CoreWindowId {
-        CoreWindowId(WindowId { fd: self.window_socket.fd as u64 })
+    fn id(&self) -> WindowId {
+        WindowId::from_raw(self.window_socket.fd)
    }

    #[inline]
@@ -181,12 +180,12 @@ impl CoreWindow for Window {

    #[inline]
    fn request_redraw(&self) {
-        let window_id = self.id().0;
+        let window_id = self.id();
        let mut redraws = self.redraws.lock().unwrap();
        if !redraws.contains(&window_id) {
            redraws.push_back(window_id);

-            self.wake_socket.wake().unwrap();
+            self.event_loop_proxy.wake_socket.wake().unwrap();
        }
    }

@@ -199,17 +198,17 @@ impl CoreWindow for Window {
    }

    #[inline]
-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        let mut buf: [u8; 4096] = [0; 4096];
-        let path = self.window_socket.fpath(&mut buf).expect("failed to read properties");
-        let properties = WindowProperties::new(path);
-        Ok((properties.x, properties.y).into())
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        // TODO: adjust for window decorations
+        (0, 0).into()
    }

    #[inline]
    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        // TODO: adjust for window decorations
-        self.inner_position()
+        let mut buf: [u8; 4096] = [0; 4096];
+        let path = self.window_socket.fpath(&mut buf).expect("failed to read properties");
+        let properties = WindowProperties::new(path);
+        Ok((properties.x, properties.y).into())
    }

    #[inline]
@@ -240,6 +239,10 @@ impl CoreWindow for Window {
        self.surface_size()
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        PhysicalInsets::new(0, 0, 0, 0)
+    }
+
    #[inline]
    fn set_min_surface_size(&self, _: Option<Size>) {}

@@ -411,7 +414,7 @@ impl CoreWindow for Window {
            window::ResizeDirection::West => "L",
        };
        self.window_socket
-            .write(format!("D,{}", arg).as_bytes())
+            .write(format!("D,{arg}").as_bytes())
            .map_err(|err| os_error!(format!("{err}")))?;
        Ok(())
    }
@@ -447,18 +450,15 @@ impl CoreWindow for Window {

    fn set_content_protected(&self, _protected: bool) {}

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_window_handle_rwh_06()?;
@@ -466,7 +466,6 @@ impl rwh_06::HasWindowHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_display_handle_rwh_06()?;
@@ -478,9 +477,9 @@ impl Drop for Window {
    fn drop(&mut self) {
        {
            let mut destroys = self.destroys.lock().unwrap();
-            destroys.push_back(self.id().0);
+            destroys.push_back(self.id());
        }

-        self.wake_socket.wake().unwrap();
+        self.event_loop_proxy.wake_socket.wake().unwrap();
    }
 }
--- a/src/platform_impl/web/async/mod.rs
+++ b/src/platform_impl/web/async/mod.rs
@@ -6,15 +6,13 @@ mod channel;
 mod concurrent_queue;
 mod dispatcher;
 mod notifier;
-mod waker;
 mod wrapper;

-use atomic_waker::AtomicWaker;
+pub(crate) use atomic_waker::AtomicWaker;
 use concurrent_queue::{ConcurrentQueue, PushError};

 pub use self::abortable::{AbortHandle, Abortable, DropAbortHandle};
 pub use self::channel::{channel, Receiver, Sender};
 pub use self::dispatcher::{DispatchRunner, Dispatcher};
 pub use self::notifier::{Notified, Notifier};
-pub use self::waker::{Waker, WakerSpawner};
-use self::wrapper::Wrapper;
+pub(crate) use self::wrapper::Wrapper;
--- a/src/platform_impl/web/async/waker.rs
+++ b/src/platform_impl/web/async/waker.rs
@@ -1,117 +0,0 @@
-use std::future;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::task::Poll;
-
-use super::super::main_thread::MainThreadMarker;
-use super::{AtomicWaker, Wrapper};
-
-pub struct WakerSpawner<T: 'static>(Wrapper<Handler<T>, Sender, ()>);
-
-pub struct Waker<T: 'static>(Wrapper<Handler<T>, Sender, ()>);
-
-struct Handler<T> {
-    value: T,
-    handler: fn(&T, bool),
-}
-
-#[derive(Clone)]
-struct Sender(Arc<Inner>);
-
-impl<T> WakerSpawner<T> {
-    pub fn new(main_thread: MainThreadMarker, value: T, handler: fn(&T, bool)) -> Self {
-        let inner = Arc::new(Inner {
-            awoken: AtomicBool::new(false),
-            waker: AtomicWaker::new(),
-            closed: AtomicBool::new(false),
-        });
-
-        let handler = Handler { value, handler };
-
-        let sender = Sender(Arc::clone(&inner));
-
-        Self(Wrapper::new(
-            main_thread,
-            handler,
-            |handler, _| {
-                let handler = handler.borrow();
-                let handler = handler.as_ref().unwrap();
-                (handler.handler)(&handler.value, true);
-            },
-            {
-                let inner = Arc::clone(&inner);
-
-                move |handler| async move {
-                    while future::poll_fn(|cx| {
-                        if inner.awoken.swap(false, Ordering::Relaxed) {
-                            Poll::Ready(true)
-                        } else {
-                            inner.waker.register(cx.waker());
-
-                            if inner.awoken.swap(false, Ordering::Relaxed) {
-                                Poll::Ready(true)
-                            } else {
-                                if inner.closed.load(Ordering::Relaxed) {
-                                    return Poll::Ready(false);
-                                }
-
-                                Poll::Pending
-                            }
-                        }
-                    })
-                    .await
-                    {
-                        let handler = handler.borrow();
-                        let handler = handler.as_ref().unwrap();
-                        (handler.handler)(&handler.value, false);
-                    }
-                }
-            },
-            sender,
-            |inner, _| {
-                inner.0.awoken.store(true, Ordering::Relaxed);
-                inner.0.waker.wake();
-            },
-        ))
-    }
-
-    pub fn waker(&self) -> Waker<T> {
-        Waker(self.0.clone())
-    }
-
-    pub fn take(&self) -> bool {
-        debug_assert!(
-            MainThreadMarker::new().is_some(),
-            "this should only be called from the main thread"
-        );
-
-        self.0.with_sender_data(|inner| inner.0.awoken.swap(false, Ordering::Relaxed))
-    }
-}
-
-impl<T> Drop for WakerSpawner<T> {
-    fn drop(&mut self) {
-        self.0.with_sender_data(|inner| {
-            inner.0.closed.store(true, Ordering::Relaxed);
-            inner.0.waker.wake();
-        });
-    }
-}
-
-impl<T> Waker<T> {
-    pub fn wake(&self) {
-        self.0.send(())
-    }
-}
-
-impl<T> Clone for Waker<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-struct Inner {
-    awoken: AtomicBool,
-    waker: AtomicWaker,
-    closed: AtomicBool,
-}
--- a/src/platform_impl/web/event.rs
+++ b/src/platform_impl/web/event.rs
@@ -1,32 +1,12 @@
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId(i32);
+use crate::event::DeviceId;

-impl DeviceId {
-    pub fn new(pointer_id: i32) -> Self {
-        Self(pointer_id)
-    }
-
-    pub const fn dummy() -> Self {
-        Self(-1)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId {
-    pointer_id: i32,
-    primary: bool,
-}
-
-impl FingerId {
-    pub fn new(pointer_id: i32, primary: bool) -> Self {
-        Self { pointer_id, primary }
-    }
-
-    pub const fn dummy() -> Self {
-        Self { pointer_id: -1, primary: false }
-    }
-
-    pub fn is_primary(self) -> bool {
-        self.primary
+pub(crate) fn mkdid(pointer_id: i32) -> Option<DeviceId> {
+    if let Ok(pointer_id) = u32::try_from(pointer_id) {
+        Some(DeviceId::from_raw(pointer_id as i64))
+    } else if pointer_id == -1 {
+        None
+    } else {
+        tracing::error!("found unexpected negative `PointerEvent.pointerId`: {pointer_id}");
+        None
    }
 }
--- a/src/platform_impl/web/event_loop/mod.rs
+++ b/src/platform_impl/web/event_loop/mod.rs
@@ -1,4 +1,4 @@
-use super::{backend, event, window, HasMonitorPermissionFuture, MonitorPermissionFuture};
+use super::{backend, HasMonitorPermissionFuture, MonitorPermissionFuture};
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, NotSupportedError};
 use crate::event::Event;
@@ -10,8 +10,7 @@ pub(crate) mod runner;
 mod state;
 mod window_target;

-pub(crate) use proxy::EventLoopProxy;
-pub(crate) use window_target::{ActiveEventLoop, OwnedDisplayHandle};
+pub(crate) use window_target::ActiveEventLoop;

 pub struct EventLoop {
    elw: ActiveEventLoop,
@@ -97,7 +96,6 @@ fn handle_event<A: ApplicationHandler>(app: &mut A, target: &ActiveEventLoop, ev
        Event::Resumed => app.resumed(target),
        Event::CreateSurfaces => app.can_create_surfaces(target),
        Event::AboutToWait => app.about_to_wait(target),
-        Event::LoopExiting => app.exiting(target),
        Event::MemoryWarning => app.memory_warning(target),
    }
 }
--- a/src/platform_impl/web/event_loop/proxy.rs
+++ b/src/platform_impl/web/event_loop/proxy.rs
@@ -1,17 +1,101 @@
-use super::runner::WeakShared;
-use crate::platform_impl::platform::r#async::Waker;
+use std::future;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::task::Poll;

-#[derive(Clone)]
-pub struct EventLoopProxy {
-    runner: Waker<WeakShared>,
+use super::super::main_thread::MainThreadMarker;
+use crate::event_loop::EventLoopProxyProvider;
+use crate::platform_impl::web::event_loop::runner::WeakShared;
+use crate::platform_impl::web::r#async::{AtomicWaker, Wrapper};
+
+pub struct EventLoopProxy(Wrapper<WeakShared, Arc<State>, ()>);
+
+struct State {
+    awoken: AtomicBool,
+    waker: AtomicWaker,
+    closed: AtomicBool,
 }

 impl EventLoopProxy {
-    pub fn new(runner: Waker<WeakShared>) -> Self {
-        Self { runner }
+    pub fn new(main_thread: MainThreadMarker, runner: WeakShared) -> Self {
+        let state = Arc::new(State {
+            awoken: AtomicBool::new(false),
+            waker: AtomicWaker::new(),
+            closed: AtomicBool::new(false),
+        });
+
+        Self(Wrapper::new(
+            main_thread,
+            runner,
+            |runner, _| {
+                let runner = runner.borrow();
+                let runner = runner.as_ref().unwrap();
+
+                if let Some(runner) = runner.upgrade() {
+                    runner.send_proxy_wake_up(true);
+                }
+            },
+            {
+                let state = Arc::clone(&state);
+
+                move |runner| async move {
+                    while future::poll_fn(|cx| {
+                        if state.awoken.swap(false, Ordering::Relaxed) {
+                            Poll::Ready(true)
+                        } else {
+                            state.waker.register(cx.waker());
+
+                            if state.awoken.swap(false, Ordering::Relaxed) {
+                                Poll::Ready(true)
+                            } else {
+                                if state.closed.load(Ordering::Relaxed) {
+                                    return Poll::Ready(false);
+                                }
+
+                                Poll::Pending
+                            }
+                        }
+                    })
+                    .await
+                    {
+                        let runner = runner.borrow();
+                        let runner = runner.as_ref().unwrap();
+
+                        if let Some(runner) = runner.upgrade() {
+                            runner.send_proxy_wake_up(false);
+                        }
+                    }
+                }
+            },
+            state,
+            |state, _| {
+                state.awoken.store(true, Ordering::Relaxed);
+                state.waker.wake();
+            },
+        ))
    }

-    pub fn wake_up(&self) {
-        self.runner.wake();
+    pub fn take(&self) -> bool {
+        debug_assert!(
+            MainThreadMarker::new().is_some(),
+            "this should only be called from the main thread"
+        );
+
+        self.0.with_sender_data(|state| state.awoken.swap(false, Ordering::Relaxed))
+    }
+}
+
+impl Drop for EventLoopProxy {
+    fn drop(&mut self) {
+        self.0.with_sender_data(|state| {
+            state.closed.store(true, Ordering::Relaxed);
+            state.waker.wake();
+        });
+    }
+}
+
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.0.send(())
    }
 }
--- a/src/platform_impl/web/event_loop/runner.rs
+++ b/src/platform_impl/web/event_loop/runner.rs
@@ -3,26 +3,25 @@ use std::collections::{HashSet, VecDeque};
 use std::iter;
 use std::ops::Deref;
 use std::rc::{Rc, Weak};
+use std::sync::Arc;

 use wasm_bindgen::prelude::Closure;
 use wasm_bindgen::JsCast;
 use web_sys::{Document, KeyboardEvent, Navigator, PageTransitionEvent, PointerEvent, WheelEvent};
 use web_time::{Duration, Instant};

+use super::super::event;
 use super::super::main_thread::MainThreadMarker;
 use super::super::monitor::MonitorHandler;
-use super::super::DeviceId;
 use super::backend;
+use super::proxy::EventLoopProxy;
 use super::state::State;
 use crate::dpi::PhysicalSize;
-use crate::event::{
-    DeviceEvent, DeviceId as RootDeviceId, ElementState, Event, RawKeyEvent, StartCause,
-    WindowEvent,
-};
+use crate::event::{DeviceEvent, ElementState, Event, RawKeyEvent, StartCause, WindowEvent};
 use crate::event_loop::{ControlFlow, DeviceEvents};
 use crate::platform::web::{PollStrategy, WaitUntilStrategy};
-use crate::platform_impl::platform::backend::EventListenerHandle;
-use crate::platform_impl::platform::r#async::{DispatchRunner, Waker, WakerSpawner};
+use crate::platform_impl::platform::backend::{EventListenerHandle, SafeAreaHandle};
+use crate::platform_impl::platform::r#async::DispatchRunner;
 use crate::platform_impl::platform::window::Inner;
 use crate::window::WindowId;

@@ -40,7 +39,7 @@ type OnEventHandle<T> = RefCell<Option<EventListenerHandle<dyn FnMut(T)>>>;

 struct Execution {
    main_thread: MainThreadMarker,
-    proxy_spawner: WakerSpawner<WeakShared>,
+    event_loop_proxy: Arc<EventLoopProxy>,
    control_flow: Cell<ControlFlow>,
    poll_strategy: Cell<PollStrategy>,
    wait_until_strategy: Cell<WaitUntilStrategy>,
@@ -49,7 +48,7 @@ struct Execution {
    suspended: Cell<bool>,
    event_loop_recreation: Cell<bool>,
    events: RefCell<VecDeque<EventWrapper>>,
-    id: RefCell<u32>,
+    id: Cell<usize>,
    window: web_sys::Window,
    navigator: Navigator,
    document: Document,
@@ -58,6 +57,7 @@ struct Execution {
    redraw_pending: RefCell<HashSet<WindowId>>,
    destroy_pending: RefCell<VecDeque<WindowId>>,
    pub(crate) monitor: Rc<MonitorHandler>,
+    safe_area: Rc<SafeAreaHandle>,
    page_transition_event_handle: RefCell<Option<backend::PageTransitionEventHandle>>,
    device_events: Cell<DeviceEvents>,
    on_mouse_move: OnEventHandle<PointerEvent>,
@@ -143,12 +143,7 @@ impl Shared {
        let document = window.document().expect("Failed to obtain document");

        Shared(Rc::<Execution>::new_cyclic(|weak| {
-            let proxy_spawner =
-                WakerSpawner::new(main_thread, WeakShared(weak.clone()), |runner, local| {
-                    if let Some(runner) = runner.upgrade() {
-                        runner.send_proxy_wake_up(local);
-                    }
-                });
+            let proxy_spawner = EventLoopProxy::new(main_thread, WeakShared(weak.clone()));

            let monitor = MonitorHandler::new(
                main_thread,
@@ -157,9 +152,11 @@ impl Shared {
                WeakShared(weak.clone()),
            );

+            let safe_area = SafeAreaHandle::new(&window, &document);
+
            Execution {
                main_thread,
-                proxy_spawner,
+                event_loop_proxy: Arc::new(proxy_spawner),
                control_flow: Cell::new(ControlFlow::default()),
                poll_strategy: Cell::new(PollStrategy::default()),
                wait_until_strategy: Cell::new(WaitUntilStrategy::default()),
@@ -171,11 +168,12 @@ impl Shared {
                window,
                navigator,
                document,
-                id: RefCell::new(0),
+                id: Cell::new(0),
                all_canvases: RefCell::new(Vec::new()),
                redraw_pending: RefCell::new(HashSet::new()),
                destroy_pending: RefCell::new(VecDeque::new()),
                monitor: Rc::new(monitor),
+                safe_area: Rc::new(safe_area),
                page_transition_event_handle: RefCell::new(None),
                device_events: Cell::default(),
                on_mouse_move: RefCell::new(None),
@@ -286,7 +284,7 @@ impl Shared {
                }

                // chorded button event
-                let device_id = RootDeviceId(DeviceId::new(event.pointer_id()));
+                let device_id = event::mkdid(event.pointer_id());

                if let Some(button) = backend::event::mouse_button(&event) {
                    let state = if backend::event::mouse_buttons(&event).contains(button.into()) {
@@ -297,7 +295,7 @@ impl Shared {

                    runner.send_event(Event::DeviceEvent {
                        device_id,
-                        event: DeviceEvent::Button { button: button.to_id(), state },
+                        event: DeviceEvent::Button { button: button.to_id().into(), state },
                    });

                    return;
@@ -310,7 +308,7 @@ impl Shared {

                    Event::DeviceEvent {
                        device_id,
-                        event: DeviceEvent::MouseMotion { delta: (delta.x, delta.y) },
+                        event: DeviceEvent::PointerMotion { delta: (delta.x, delta.y) },
                    }
                }));
            }),
@@ -327,7 +325,7 @@ impl Shared {

                if let Some(delta) = backend::event::mouse_scroll_delta(&window, &event) {
                    runner.send_event(Event::DeviceEvent {
-                        device_id: RootDeviceId(DeviceId::dummy()),
+                        device_id: None,
                        event: DeviceEvent::MouseWheel { delta },
                    });
                }
@@ -344,9 +342,9 @@ impl Shared {

                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                runner.send_event(Event::DeviceEvent {
-                    device_id: RootDeviceId(DeviceId::new(event.pointer_id())),
+                    device_id: event::mkdid(event.pointer_id()),
                    event: DeviceEvent::Button {
-                        button: button.to_id(),
+                        button: button.to_id().into(),
                        state: ElementState::Pressed,
                    },
                });
@@ -363,9 +361,9 @@ impl Shared {

                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                runner.send_event(Event::DeviceEvent {
-                    device_id: RootDeviceId(DeviceId::new(event.pointer_id())),
+                    device_id: event::mkdid(event.pointer_id()),
                    event: DeviceEvent::Button {
-                        button: button.to_id(),
+                        button: button.to_id().into(),
                        state: ElementState::Released,
                    },
                });
@@ -381,7 +379,7 @@ impl Shared {
                }

                runner.send_event(Event::DeviceEvent {
-                    device_id: RootDeviceId(DeviceId::dummy()),
+                    device_id: None,
                    event: DeviceEvent::Key(RawKeyEvent {
                        physical_key: backend::event::key_code(&event),
                        state: ElementState::Pressed,
@@ -399,7 +397,7 @@ impl Shared {
                }

                runner.send_event(Event::DeviceEvent {
-                    device_id: RootDeviceId(DeviceId::dummy()),
+                    device_id: None,
                    event: DeviceEvent::Key(RawKeyEvent {
                        physical_key: backend::event::key_code(&event),
                        state: ElementState::Released,
@@ -438,11 +436,11 @@ impl Shared {

    // Generate a strictly increasing ID
    // This is used to differentiate windows when handling events
-    pub fn generate_id(&self) -> u32 {
-        let mut id = self.0.id.borrow_mut();
-        *id += 1;
+    pub fn generate_id(&self) -> usize {
+        let id = self.0.id.get();
+        self.0.id.set(id.checked_add(1).expect("exhausted `WindowId`"));

-        *id
+        id
    }

    pub fn request_redraw(&self, id: WindowId) {
@@ -611,7 +609,7 @@ impl Shared {
        self.apply_control_flow();
        // We don't call `handle_loop_destroyed` here because we don't need to
        // perform cleanup when the Web browser is going to destroy the page.
-        self.handle_event(Event::LoopExiting);
+        todo!("drop the application handler");
    }

    // handle_event takes in events and either queues them or applies a callback
@@ -656,7 +654,7 @@ impl Shared {
                // Pre-fetch `UserEvent`s to avoid having to wait until the next event loop cycle.
                events.extend(
                    self.0
-                        .proxy_spawner
+                        .event_loop_proxy
                        .take()
                        .then_some(Event::UserWakeUp)
                        .map(EventWrapper::from),
@@ -715,7 +713,7 @@ impl Shared {
    }

    fn handle_loop_destroyed(&self) {
-        self.handle_event(Event::LoopExiting);
+        todo!("drop the application handler");
        let all_canvases = std::mem::take(&mut *self.0.all_canvases.borrow_mut());
        *self.0.page_transition_event_handle.borrow_mut() = None;
        *self.0.on_mouse_move.borrow_mut() = None;
@@ -821,8 +819,8 @@ impl Shared {
        self.0.wait_until_strategy.get()
    }

-    pub(crate) fn waker(&self) -> Waker<WeakShared> {
-        self.0.proxy_spawner.waker()
+    pub(crate) fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
+        &self.0.event_loop_proxy
    }

    pub(crate) fn weak(&self) -> WeakShared {
@@ -832,6 +830,10 @@ impl Shared {
    pub(crate) fn monitor(&self) -> &Rc<MonitorHandler> {
        &self.0.monitor
    }
+
+    pub(crate) fn safe_area(&self) -> &Rc<SafeAreaHandle> {
+        &self.0.safe_area
+    }
 }

 #[derive(Clone, Debug)]
--- a/src/platform_impl/web/event_loop/window_target.rs
+++ b/src/platform_impl/web/event_loop/window_target.rs
@@ -2,33 +2,27 @@ use std::cell::Cell;
 use std::clone::Clone;
 use std::iter;
 use std::rc::Rc;
+use std::sync::Arc;

 use web_sys::Element;

 use super::super::monitor::MonitorPermissionFuture;
 use super::super::{lock, KeyEventExtra};
-use super::event::DeviceId;
-use super::runner::{EventWrapper, WeakShared};
-use super::window::WindowId;
-use super::{backend, runner, EventLoopProxy};
+use super::runner::EventWrapper;
+use super::{backend, runner};
 use crate::error::{NotSupportedError, RequestError};
-use crate::event::{
-    DeviceId as RootDeviceId, ElementState, Event, FingerId as RootFingerId, KeyEvent, Touch,
-    TouchPhase, WindowEvent,
-};
+use crate::event::{ElementState, Event, KeyEvent, TouchPhase, WindowEvent};
 use crate::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
+    EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::keyboard::ModifiersState;
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform::web::{CustomCursorFuture, PollStrategy, WaitUntilStrategy};
 use crate::platform_impl::platform::cursor::CustomCursor;
-use crate::platform_impl::platform::r#async::Waker;
+use crate::platform_impl::web::event_loop::proxy::EventLoopProxy;
 use crate::platform_impl::Window;
-use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId as RootWindowId,
-};
+use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId};

 #[derive(Default)]
 struct ModifiersShared(Rc<Cell<ModifiersState>>);
@@ -70,14 +64,14 @@ impl ActiveEventLoop {
    }

    pub fn generate_id(&self) -> WindowId {
-        WindowId(self.runner.generate_id())
+        WindowId::from_raw(self.runner.generate_id())
    }

    pub fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
        CustomCursorFuture(CustomCursor::new_async(self, source.inner))
    }

-    pub fn register(&self, canvas: &Rc<backend::Canvas>, id: WindowId) {
+    pub fn register(&self, canvas: &Rc<backend::Canvas>, window_id: WindowId) {
        let canvas_clone = canvas.clone();

        canvas.on_touch_start();
@@ -91,13 +85,13 @@ impl ActiveEventLoop {
            let clear_modifiers = (!modifiers.get().is_empty()).then(|| {
                modifiers.set(ModifiersState::empty());
                Event::WindowEvent {
-                    window_id: RootWindowId(id),
+                    window_id,
                    event: WindowEvent::ModifiersChanged(ModifiersState::empty().into()),
                }
            });

            runner.send_events(clear_modifiers.into_iter().chain(iter::once(Event::WindowEvent {
-                window_id: RootWindowId(id),
+                window_id,
                event: WindowEvent::Focused(false),
            })));
        });
@@ -107,7 +101,7 @@ impl ActiveEventLoop {
        canvas.on_focus(move || {
            if !has_focus.replace(true) {
                runner.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(id),
+                    window_id,
                    event: WindowEvent::Focused(true),
                });
            }
@@ -126,10 +120,8 @@ impl ActiveEventLoop {

        if focused {
            canvas.has_focus.set(true);
-            self.runner.send_event(Event::WindowEvent {
-                window_id: RootWindowId(id),
-                event: WindowEvent::Focused(true),
-            })
+            self.runner
+                .send_event(Event::WindowEvent { window_id, event: WindowEvent::Focused(true) })
        }

        let runner = self.runner.clone();
@@ -139,18 +131,16 @@ impl ActiveEventLoop {
                let modifiers_changed = (modifiers.get() != active_modifiers).then(|| {
                    modifiers.set(active_modifiers);
                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                    }
                });

-                let device_id = RootDeviceId(DeviceId::dummy());
-
                runner.send_events(
                    iter::once(Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::KeyboardInput {
-                            device_id,
+                            device_id: None,
                            event: KeyEvent {
                                physical_key,
                                logical_key,
@@ -175,18 +165,16 @@ impl ActiveEventLoop {
                let modifiers_changed = (modifiers.get() != active_modifiers).then(|| {
                    modifiers.set(active_modifiers);
                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                    }
                });

-                let device_id = RootDeviceId(DeviceId::dummy());
-
                runner.send_events(
                    iter::once(Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::KeyboardInput {
-                            device_id,
+                            device_id: None,
                            event: KeyEvent {
                                physical_key,
                                logical_key,
@@ -205,80 +193,85 @@ impl ActiveEventLoop {
        );

        let has_focus = canvas.has_focus.clone();
-        canvas.on_cursor_leave({
+        canvas.on_pointer_leave({
            let runner = self.runner.clone();
            let has_focus = has_focus.clone();
            let modifiers = self.modifiers.clone();

-            move |active_modifiers, pointer_id| {
+            move |active_modifiers, device_id, primary, position, kind| {
                let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                    modifiers.set(active_modifiers);
                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                    }
                });

-                let pointer = pointer_id.map(|device_id| Event::WindowEvent {
-                    window_id: RootWindowId(id),
-                    event: WindowEvent::CursorLeft { device_id: RootDeviceId(device_id) },
-                });
-
-                if focus.is_some() || pointer.is_some() {
-                    runner.send_events(focus.into_iter().chain(pointer))
-                }
+                runner.send_events(focus.into_iter().chain(iter::once(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::PointerLeft {
+                        device_id,
+                        primary,
+                        position: Some(position),
+                        kind,
+                    },
+                })))
            }
        });

-        canvas.on_cursor_enter({
+        canvas.on_pointer_enter({
            let runner = self.runner.clone();
            let has_focus = has_focus.clone();
            let modifiers = self.modifiers.clone();

-            move |active_modifiers, pointer_id| {
+            move |active_modifiers, device_id, primary, position, kind| {
                let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                    modifiers.set(active_modifiers);
                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                    }
                });

-                let pointer = pointer_id.map(|device_id| Event::WindowEvent {
-                    window_id: RootWindowId(id),
-                    event: WindowEvent::CursorEntered { device_id: RootDeviceId(device_id) },
-                });
-
-                if focus.is_some() || pointer.is_some() {
-                    runner.send_events(focus.into_iter().chain(pointer))
-                }
+                runner.send_events(focus.into_iter().chain(iter::once(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::PointerEntered { device_id, primary, position, kind },
+                })))
            }
        });

-        canvas.on_cursor_move(
+        canvas.on_pointer_move(
            {
                let runner = self.runner.clone();
                let has_focus = has_focus.clone();
                let modifiers = self.modifiers.clone();

-                move |active_modifiers, pointer_id, events| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                            modifiers.set(active_modifiers);
-                            Event::WindowEvent {
-                                window_id: RootWindowId(id),
-                                event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                            }
-                        });
+                move |device_id, events| {
+                    runner.send_events(events.flat_map(
+                        |(active_modifiers, primary, position, source)| {
+                            let modifiers = (has_focus.get()
+                                && modifiers.get() != active_modifiers)
+                                .then(|| {
+                                    modifiers.set(active_modifiers);
+                                    Event::WindowEvent {
+                                        window_id,
+                                        event: WindowEvent::ModifiersChanged(
+                                            active_modifiers.into(),
+                                        ),
+                                    }
+                                });

-                    runner.send_events(modifiers.into_iter().chain(events.flat_map(|position| {
-                        let device_id = RootDeviceId(pointer_id);
-
-                        iter::once(Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::CursorMoved { device_id, position },
-                        })
-                    })));
+                            modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                                window_id,
+                                event: WindowEvent::PointerMoved {
+                                    device_id,
+                                    primary,
+                                    position,
+                                    source,
+                                },
+                            }))
+                        },
+                    ));
                }
            },
            {
@@ -286,205 +279,83 @@ impl ActiveEventLoop {
                let has_focus = has_focus.clone();
                let modifiers = self.modifiers.clone();

-                move |active_modifiers, device_id, finger_id, events| {
+                move |active_modifiers, device_id, primary, position, state, button| {
                    let modifiers =
                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                            modifiers.set(active_modifiers);
                            Event::WindowEvent {
-                                window_id: RootWindowId(id),
+                                window_id,
                                event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                            }
                        });

-                    runner.send_events(modifiers.into_iter().chain(events.map(
-                        |(location, force)| Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::Touch(Touch {
-                                finger_id: RootFingerId(finger_id),
-                                device_id: RootDeviceId(device_id),
-                                phase: TouchPhase::Moved,
-                                force: Some(force),
-                                location,
-                            }),
+                    runner.send_events(modifiers.into_iter().chain([Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::PointerButton {
+                            device_id,
+                            primary,
+                            state,
+                            position,
+                            button,
                        },
-                    )));
-                }
-            },
-            {
-                let runner = self.runner.clone();
-                let has_focus = has_focus.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers,
-                      device_id,
-                      position: crate::dpi::PhysicalPosition<f64>,
-                      buttons,
-                      button| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                            modifiers.set(active_modifiers);
-                            Event::WindowEvent {
-                                window_id: RootWindowId(id),
-                                event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                            }
-                        });
-
-                    let device_id = RootDeviceId(device_id);
-
-                    let state = if buttons.contains(button.into()) {
-                        ElementState::Pressed
-                    } else {
-                        ElementState::Released
-                    };
-
-                    // A chorded button event may come in without any prior CursorMoved events,
-                    // therefore we should send a CursorMoved event to make sure that the
-                    // user code has the correct cursor position.
-                    runner.send_events(modifiers.into_iter().chain([
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::CursorMoved { device_id, position },
-                        },
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::MouseInput { device_id, state, button },
-                        },
-                    ]));
+                    }]));
                }
            },
        );

-        canvas.on_mouse_press(
-            {
-                let runner = self.runner.clone();
-                let modifiers = self.modifiers.clone();
+        canvas.on_pointer_press({
+            let runner = self.runner.clone();
+            let modifiers = self.modifiers.clone();

-                move |active_modifiers, pointer_id, position, button| {
-                    let modifiers = (modifiers.get() != active_modifiers).then(|| {
+            move |active_modifiers, device_id, primary, position, button| {
+                let modifiers = (modifiers.get() != active_modifiers).then(|| {
+                    modifiers.set(active_modifiers);
+                    Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
+                    }
+                });
+
+                runner.send_events(modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::PointerButton {
+                        device_id,
+                        primary,
+                        state: ElementState::Pressed,
+                        position,
+                        button,
+                    },
+                })));
+            }
+        });
+
+        canvas.on_pointer_release({
+            let runner = self.runner.clone();
+            let has_focus = has_focus.clone();
+            let modifiers = self.modifiers.clone();
+
+            move |active_modifiers, device_id, primary, position, button| {
+                let modifiers =
+                    (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                        modifiers.set(active_modifiers);
                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
+                            window_id,
                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                        }
                    });

-                    let device_id: RootDeviceId = RootDeviceId(pointer_id);
-
-                    // A mouse down event may come in without any prior CursorMoved events,
-                    // therefore we should send a CursorMoved event to make sure that the
-                    // user code has the correct cursor position.
-                    runner.send_events(modifiers.into_iter().chain([
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::CursorMoved { device_id, position },
-                        },
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::MouseInput {
-                                device_id,
-                                state: ElementState::Pressed,
-                                button,
-                            },
-                        },
-                    ]));
-                }
-            },
-            {
-                let runner = self.runner.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers, device_id, finger_id, location, force| {
-                    let modifiers = (modifiers.get() != active_modifiers).then(|| {
-                        modifiers.set(active_modifiers);
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                        }
-                    });
-
-                    runner.send_events(modifiers.into_iter().chain(iter::once(
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::Touch(Touch {
-                                finger_id: RootFingerId(finger_id),
-                                device_id: RootDeviceId(device_id),
-                                phase: TouchPhase::Started,
-                                force: Some(force),
-                                location,
-                            }),
-                        },
-                    )))
-                }
-            },
-        );
-
-        canvas.on_mouse_release(
-            {
-                let runner = self.runner.clone();
-                let has_focus = has_focus.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers, pointer_id, position, button| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                            modifiers.set(active_modifiers);
-                            Event::WindowEvent {
-                                window_id: RootWindowId(id),
-                                event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                            }
-                        });
-
-                    let device_id: RootDeviceId = RootDeviceId(pointer_id);
-
-                    // A mouse up event may come in without any prior CursorMoved events,
-                    // therefore we should send a CursorMoved event to make sure that the
-                    // user code has the correct cursor position.
-                    runner.send_events(modifiers.into_iter().chain([
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::CursorMoved { device_id, position },
-                        },
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::MouseInput {
-                                device_id,
-                                state: ElementState::Released,
-                                button,
-                            },
-                        },
-                    ]));
-                }
-            },
-            {
-                let runner_touch = self.runner.clone();
-                let has_focus = has_focus.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers, device_id, finger_id, location, force| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                            modifiers.set(active_modifiers);
-                            Event::WindowEvent {
-                                window_id: RootWindowId(id),
-                                event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                            }
-                        });
-
-                    runner_touch.send_events(modifiers.into_iter().chain(iter::once(
-                        Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::Touch(Touch {
-                                finger_id: RootFingerId(finger_id),
-                                device_id: RootDeviceId(device_id),
-                                phase: TouchPhase::Ended,
-                                force: Some(force),
-                                location,
-                            }),
-                        },
-                    )));
-                }
-            },
-        );
+                runner.send_events(modifiers.into_iter().chain(iter::once(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::PointerButton {
+                        device_id,
+                        primary,
+                        state: ElementState::Released,
+                        position,
+                        button,
+                    },
+                })));
+            }
+        });

        let runner = self.runner.clone();
        let modifiers = self.modifiers.clone();
@@ -493,16 +364,16 @@ impl ActiveEventLoop {
                (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
                    modifiers.set(active_modifiers);
                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
+                        window_id,
                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
                    }
                });

            runner.send_events(modifiers_changed.into_iter().chain(iter::once(
                Event::WindowEvent {
-                    window_id: RootWindowId(id),
+                    window_id,
                    event: WindowEvent::MouseWheel {
-                        device_id: RootDeviceId(DeviceId::dummy()),
+                        device_id: None,
                        delta,
                        phase: TouchPhase::Moved,
                    },
@@ -510,25 +381,11 @@ impl ActiveEventLoop {
            )));
        });

-        let runner = self.runner.clone();
-        canvas.on_touch_cancel(move |device_id, finger_id, location, force| {
-            runner.send_event(Event::WindowEvent {
-                window_id: RootWindowId(id),
-                event: WindowEvent::Touch(Touch {
-                    finger_id: RootFingerId(finger_id),
-                    device_id: RootDeviceId(device_id),
-                    phase: TouchPhase::Cancelled,
-                    force: Some(force),
-                    location,
-                }),
-            });
-        });
-
        let runner = self.runner.clone();
        canvas.on_dark_mode(move |is_dark_mode| {
            let theme = if is_dark_mode { Theme::Dark } else { Theme::Light };
            runner.send_event(Event::WindowEvent {
-                window_id: RootWindowId(id),
+                window_id,
                event: WindowEvent::ThemeChanged(theme),
            });
        });
@@ -555,7 +412,7 @@ impl ActiveEventLoop {
                    if canvas.old_size() != new_size {
                        canvas.set_old_size(new_size);
                        runner.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(id),
+                            window_id,
                            event: WindowEvent::SurfaceResized(new_size),
                        });
                        canvas.request_animation_frame();
@@ -571,7 +428,7 @@ impl ActiveEventLoop {
                && !(is_intersecting && canvas_clone.is_intersecting.get().is_none())
            {
                runner.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(id),
+                    window_id,
                    event: WindowEvent::Occluded(!is_intersecting),
                });
            }
@@ -580,7 +437,7 @@ impl ActiveEventLoop {
        });

        let runner = self.runner.clone();
-        canvas.on_animation_frame(move || runner.request_redraw(RootWindowId(id)));
+        canvas.on_animation_frame(move || runner.request_redraw(window_id));

        canvas.on_context_menu();
    }
@@ -620,15 +477,15 @@ impl ActiveEventLoop {
        self.runner.monitor().has_detailed_monitor_permission()
    }

-    pub(crate) fn waker(&self) -> Waker<WeakShared> {
-        self.runner.waker()
+    pub(crate) fn event_loop_proxy(&self) -> Arc<EventLoopProxy> {
+        self.runner.event_loop_proxy().clone()
    }
 }

 impl RootActiveEventLoop for ActiveEventLoop {
    fn create_proxy(&self) -> RootEventLoopProxy {
-        let event_loop_proxy = EventLoopProxy::new(self.waker());
-        RootEventLoopProxy { event_loop_proxy }
+        let event_loop_proxy = self.event_loop_proxy();
+        RootEventLoopProxy::new(event_loop_proxy)
    }

    fn create_window(
@@ -690,17 +547,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
        self.runner.exiting()
    }

-    fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
-        RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
+    fn owned_display_handle(&self) -> CoreOwnedDisplayHandle {
+        CoreOwnedDisplayHandle::new(Arc::new(OwnedDisplayHandle))
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = rwh_06::RawDisplayHandle::Web(rwh_06::WebDisplayHandle::new());
@@ -708,15 +563,12 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    }
 }

-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone)]
 pub(crate) struct OwnedDisplayHandle;

-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::WebDisplayHandle::new().into())
+impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::RawDisplayHandle::Web(rwh_06::WebDisplayHandle::new());
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
    }
 }
--- a/src/platform_impl/web/mod.rs
+++ b/src/platform_impl/web/mod.rs
@@ -37,10 +37,8 @@ pub(crate) use cursor::{
    CustomCursorSource as PlatformCustomCursorSource,
 };

-pub use self::event::{DeviceId, FingerId};
 pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
-    PlatformSpecificEventLoopAttributes,
+    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
 };
 pub(crate) use self::keyboard::KeyEventExtra;
 pub(crate) use self::monitor::{
@@ -48,5 +46,5 @@ pub(crate) use self::monitor::{
    VideoModeHandle,
 };
 use self::web_sys as backend;
-pub use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
+pub use self::window::{PlatformSpecificWindowAttributes, Window};
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
--- a/src/platform_impl/web/web_sys/canvas.rs
+++ b/src/platform_impl/web/web_sys/canvas.rs
@@ -12,21 +12,22 @@ use web_sys::{
 };

 use super::super::cursor::CursorHandler;
-use super::super::event::{DeviceId, FingerId};
 use super::super::main_thread::MainThreadMarker;
-use super::super::WindowId;
 use super::animation_frame::AnimationFrameHandler;
 use super::event_handle::EventListenerHandle;
 use super::intersection_handle::IntersectionObserverHandle;
 use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
-use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
+use super::{event, fullscreen, ResizeScaleHandle};
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use crate::error::RequestError;
-use crate::event::{Force, MouseButton, MouseScrollDelta, SurfaceSizeWriter};
+use crate::event::{
+    ButtonSource, DeviceId, ElementState, MouseScrollDelta, PointerKind, PointerSource,
+    SurfaceSizeWriter,
+};
 use crate::keyboard::{Key, KeyLocation, ModifiersState, PhysicalKey};
 use crate::platform_impl::Fullscreen;
-use crate::window::{WindowAttributes, WindowId as RootWindowId};
+use crate::window::{WindowAttributes, WindowId};

 #[allow(dead_code)]
 pub struct Canvas {
@@ -71,8 +72,8 @@ pub struct Common {

 #[derive(Clone, Debug)]
 pub struct Style {
-    read: CssStyleDeclaration,
-    write: CssStyleDeclaration,
+    pub(super) read: CssStyleDeclaration,
+    pub(super) write: CssStyleDeclaration,
 }

 impl Canvas {
@@ -328,75 +329,69 @@ impl Canvas {
            }));
    }

-    pub fn on_cursor_leave<F>(&self, handler: F)
+    pub fn on_pointer_leave<F>(&self, handler: F)
    where
-        F: 'static + FnMut(ModifiersState, Option<DeviceId>),
+        F: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, PointerKind),
    {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_leave(&self.common, handler)
+        self.handlers.borrow_mut().pointer_handler.on_pointer_leave(&self.common, handler)
    }

-    pub fn on_cursor_enter<F>(&self, handler: F)
+    pub fn on_pointer_enter<F>(&self, handler: F)
    where
-        F: 'static + FnMut(ModifiersState, Option<DeviceId>),
+        F: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, PointerKind),
    {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_enter(&self.common, handler)
+        self.handlers.borrow_mut().pointer_handler.on_pointer_enter(&self.common, handler)
    }

-    pub fn on_mouse_release<M, T>(&self, mouse_handler: M, touch_handler: T)
+    pub fn on_pointer_release<C>(&self, handler: C)
    where
-        M: 'static + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, MouseButton),
-        T: 'static + FnMut(ModifiersState, DeviceId, FingerId, PhysicalPosition<f64>, Force),
+        C: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, ButtonSource),
    {
-        self.handlers.borrow_mut().pointer_handler.on_mouse_release(
+        self.handlers.borrow_mut().pointer_handler.on_pointer_release(&self.common, handler)
+    }
+
+    pub fn on_pointer_press<C>(&self, handler: C)
+    where
+        C: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, ButtonSource),
+    {
+        self.handlers.borrow_mut().pointer_handler.on_pointer_press(
            &self.common,
-            mouse_handler,
-            touch_handler,
-        )
-    }
-
-    pub fn on_mouse_press<M, T>(&self, mouse_handler: M, touch_handler: T)
-    where
-        M: 'static + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, MouseButton),
-        T: 'static + FnMut(ModifiersState, DeviceId, FingerId, PhysicalPosition<f64>, Force),
-    {
-        self.handlers.borrow_mut().pointer_handler.on_mouse_press(
-            &self.common,
-            mouse_handler,
-            touch_handler,
+            handler,
            Rc::clone(&self.prevent_default),
        )
    }

-    pub fn on_cursor_move<M, T, B>(&self, mouse_handler: M, touch_handler: T, button_handler: B)
+    pub fn on_pointer_move<C, B>(&self, cursor_handler: C, button_handler: B)
    where
-        M: 'static
-            + FnMut(ModifiersState, DeviceId, &mut dyn Iterator<Item = PhysicalPosition<f64>>),
-        T: 'static
+        C: 'static
            + FnMut(
-                ModifiersState,
-                DeviceId,
-                FingerId,
-                &mut dyn Iterator<Item = (PhysicalPosition<f64>, Force)>,
+                Option<DeviceId>,
+                &mut dyn Iterator<
+                    Item = (ModifiersState, bool, PhysicalPosition<f64>, PointerSource),
+                >,
            ),
        B: 'static
-            + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, ButtonsState, MouseButton),
+            + FnMut(
+                ModifiersState,
+                Option<DeviceId>,
+                bool,
+                PhysicalPosition<f64>,
+                ElementState,
+                ButtonSource,
+            ),
    {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_move(
+        self.handlers.borrow_mut().pointer_handler.on_pointer_move(
            &self.common,
-            mouse_handler,
-            touch_handler,
+            cursor_handler,
            button_handler,
            Rc::clone(&self.prevent_default),
        )
    }

-    pub fn on_touch_cancel<F>(&self, handler: F)
-    where
-        F: 'static + FnMut(DeviceId, FingerId, PhysicalPosition<f64>, Force),
-    {
-        self.handlers.borrow_mut().pointer_handler.on_touch_cancel(&self.common, handler)
-    }
-
    pub fn on_mouse_wheel<F>(&self, mut handler: F)
    where
        F: 'static + FnMut(MouseScrollDelta, ModifiersState),
@@ -501,7 +496,7 @@ impl Canvas {
        let new_size = {
            let new_size = Arc::new(Mutex::new(current_size));
            event_handler(crate::event::Event::WindowEvent {
-                window_id: RootWindowId(self.id),
+                window_id: self.id,
                event: crate::event::WindowEvent::ScaleFactorChanged {
                    scale_factor: scale,
                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_size)),
@@ -529,7 +524,7 @@ impl Canvas {
            // Then we at least send a resized event.
            self.set_old_size(new_size);
            runner.send_event(crate::event::Event::WindowEvent {
-                window_id: RootWindowId(self.id),
+                window_id: self.id,
                event: crate::event::WindowEvent::SurfaceResized(new_size),
            })
        }
--- a/src/platform_impl/web/web_sys/event.rs
+++ b/src/platform_impl/web/web_sys/event.rs
@@ -7,7 +7,7 @@ use wasm_bindgen::{JsCast, JsValue};
 use web_sys::{KeyboardEvent, MouseEvent, Navigator, PointerEvent, WheelEvent};

 use super::Engine;
-use crate::event::{MouseButton, MouseScrollDelta};
+use crate::event::{FingerId, MouseButton, MouseScrollDelta, PointerKind};
 use crate::keyboard::{Key, KeyLocation, ModifiersState, NamedKey, PhysicalKey};

 bitflags::bitflags! {
@@ -68,14 +68,14 @@ pub fn mouse_button(event: &MouseEvent) -> Option<MouseButton> {
 }

 impl MouseButton {
-    pub fn to_id(self) -> u32 {
+    pub fn to_id(self) -> u16 {
        match self {
            MouseButton::Left => 0,
            MouseButton::Right => 1,
            MouseButton::Middle => 2,
            MouseButton::Back => 3,
            MouseButton::Forward => 4,
-            MouseButton::Other(value) => value.into(),
+            MouseButton::Other(value) => value,
        }
    }
 }
@@ -160,6 +160,14 @@ pub fn mouse_scroll_delta(
    }
 }

+pub fn pointer_type(event: &PointerEvent, pointer_id: i32) -> PointerKind {
+    match event.pointer_type().as_str() {
+        "mouse" => PointerKind::Mouse,
+        "touch" => PointerKind::Touch(FingerId::from_raw(pointer_id as usize)),
+        _ => PointerKind::Unknown,
+    }
+}
+
 pub fn key_code(event: &KeyboardEvent) -> PhysicalKey {
    let code = event.code();
    PhysicalKey::from_key_code_attribute_value(&code)
--- a/src/platform_impl/web/web_sys/mod.rs
+++ b/src/platform_impl/web/web_sys/mod.rs
@@ -7,6 +7,7 @@ mod intersection_handle;
 mod media_query_handle;
 mod pointer;
 mod resize_scaling;
+mod safe_area;
 mod schedule;

 use std::cell::OnceCell;
@@ -18,9 +19,9 @@ use wasm_bindgen::JsCast;
 use web_sys::{Document, HtmlCanvasElement, Navigator, PageTransitionEvent, VisibilityState};

 pub use self::canvas::{Canvas, Style};
-pub use self::event::ButtonsState;
 pub use self::event_handle::EventListenerHandle;
 pub use self::resize_scaling::ResizeScaleHandle;
+pub use self::safe_area::SafeAreaHandle;
 pub use self::schedule::Schedule;
 use crate::dpi::{LogicalPosition, LogicalSize};

--- a/src/platform_impl/web/web_sys/pointer.rs
+++ b/src/platform_impl/web/web_sys/pointer.rs
@@ -1,16 +1,15 @@
 use std::cell::Cell;
 use std::rc::Rc;

-use event::ButtonsState;
 use web_sys::PointerEvent;

-use super::super::event::{DeviceId, FingerId};
 use super::canvas::Common;
 use super::event;
 use super::event_handle::EventListenerHandle;
 use crate::dpi::PhysicalPosition;
-use crate::event::{Force, MouseButton};
+use crate::event::{ButtonSource, DeviceId, ElementState, Force, PointerKind, PointerSource};
 use crate::keyboard::ModifiersState;
+use crate::platform_impl::web::event::mkdid;

 #[allow(dead_code)]
 pub(super) struct PointerHandler {
@@ -34,86 +33,83 @@ impl PointerHandler {
        }
    }

-    pub fn on_cursor_leave<F>(&mut self, canvas_common: &Common, mut handler: F)
+    pub fn on_pointer_leave<F>(&mut self, canvas_common: &Common, mut handler: F)
    where
-        F: 'static + FnMut(ModifiersState, Option<DeviceId>),
+        F: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, PointerKind),
    {
+        let window = canvas_common.window.clone();
        self.on_cursor_leave =
            Some(canvas_common.add_event("pointerout", move |event: PointerEvent| {
                let modifiers = event::mouse_modifiers(&event);
-
-                // touch events are handled separately
-                // handling them here would produce duplicate mouse events, inconsistent with
-                // other platforms.
-                let device_id =
-                    (event.pointer_type() != "touch").then(|| DeviceId::new(event.pointer_id()));
-
-                handler(modifiers, device_id);
+                let pointer_id = event.pointer_id();
+                let device_id = mkdid(pointer_id);
+                let position =
+                    event::mouse_position(&event).to_physical(super::scale_factor(&window));
+                let kind = event::pointer_type(&event, pointer_id);
+                handler(modifiers, device_id, event.is_primary(), position, kind);
            }));
    }

-    pub fn on_cursor_enter<F>(&mut self, canvas_common: &Common, mut handler: F)
+    pub fn on_pointer_enter<F>(&mut self, canvas_common: &Common, mut handler: F)
    where
-        F: 'static + FnMut(ModifiersState, Option<DeviceId>),
+        F: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, PointerKind),
    {
+        let window = canvas_common.window.clone();
        self.on_cursor_enter =
            Some(canvas_common.add_event("pointerover", move |event: PointerEvent| {
                let modifiers = event::mouse_modifiers(&event);
-
-                // touch events are handled separately
-                // handling them here would produce duplicate mouse events, inconsistent with
-                // other platforms.
-                let device_id =
-                    (event.pointer_type() != "touch").then(|| DeviceId::new(event.pointer_id()));
-
-                handler(modifiers, device_id);
+                let pointer_id = event.pointer_id();
+                let device_id = mkdid(pointer_id);
+                let position =
+                    event::mouse_position(&event).to_physical(super::scale_factor(&window));
+                let kind = event::pointer_type(&event, pointer_id);
+                handler(modifiers, device_id, event.is_primary(), position, kind);
            }));
    }

-    pub fn on_mouse_release<M, T>(
-        &mut self,
-        canvas_common: &Common,
-        mut mouse_handler: M,
-        mut touch_handler: T,
-    ) where
-        M: 'static + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, MouseButton),
-        T: 'static + FnMut(ModifiersState, DeviceId, FingerId, PhysicalPosition<f64>, Force),
+    pub fn on_pointer_release<C>(&mut self, canvas_common: &Common, mut handler: C)
+    where
+        C: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, ButtonSource),
    {
        let window = canvas_common.window.clone();
        self.on_pointer_release =
            Some(canvas_common.add_event("pointerup", move |event: PointerEvent| {
                let modifiers = event::mouse_modifiers(&event);
+                let pointer_id = event.pointer_id();
+                let kind = event::pointer_type(&event, pointer_id);

-                match event.pointer_type().as_str() {
-                    "touch" => {
-                        let pointer_id = event.pointer_id();
-                        touch_handler(
-                            modifiers,
-                            DeviceId::new(pointer_id),
-                            FingerId::new(pointer_id, event.is_primary()),
-                            event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                            Force::Normalized(event.pressure() as f64),
-                        )
+                let button = event::mouse_button(&event).expect("no mouse button pressed");
+
+                let source = match kind {
+                    PointerKind::Mouse => ButtonSource::Mouse(button),
+                    PointerKind::Touch(finger_id) => ButtonSource::Touch {
+                        finger_id,
+                        force: Some(Force::Normalized(event.pressure().into())),
                    },
-                    _ => mouse_handler(
-                        modifiers,
-                        DeviceId::new(event.pointer_id()),
-                        event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                        event::mouse_button(&event).expect("no mouse button released"),
-                    ),
-                }
+                    PointerKind::Unknown => ButtonSource::Unknown(button.to_id()),
+                };
+
+                handler(
+                    modifiers,
+                    mkdid(pointer_id),
+                    event.is_primary(),
+                    event::mouse_position(&event).to_physical(super::scale_factor(&window)),
+                    source,
+                )
            }));
    }

-    pub fn on_mouse_press<M, T>(
+    pub fn on_pointer_press<C>(
        &mut self,
        canvas_common: &Common,
-        mut mouse_handler: M,
-        mut touch_handler: T,
+        mut handler: C,
        prevent_default: Rc<Cell<bool>>,
    ) where
-        M: 'static + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, MouseButton),
-        T: 'static + FnMut(ModifiersState, DeviceId, FingerId, PhysicalPosition<f64>, Force),
+        C: 'static
+            + FnMut(ModifiersState, Option<DeviceId>, bool, PhysicalPosition<f64>, ButtonSource),
    {
        let window = canvas_common.window.clone();
        let canvas = canvas_common.raw().clone();
@@ -127,69 +123,70 @@ impl PointerHandler {
                }

                let modifiers = event::mouse_modifiers(&event);
-                let pointer_type = &event.pointer_type();
+                let pointer_id = event.pointer_id();
+                let kind = event::pointer_type(&event, pointer_id);
+                let button = event::mouse_button(&event).expect("no mouse button pressed");

-                match pointer_type.as_str() {
-                    "touch" => {
-                        let pointer_id = event.pointer_id();
-                        touch_handler(
-                            modifiers,
-                            DeviceId::new(pointer_id),
-                            FingerId::new(pointer_id, event.is_primary()),
-                            event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                            Force::Normalized(event.pressure() as f64),
-                        );
+                let source = match kind {
+                    PointerKind::Mouse => {
+                        // Error is swallowed here since the error would occur every time the
+                        // mouse is clicked when the cursor is
+                        // grabbed, and there is probably not a
+                        // situation where this could fail, that we
+                        // care if it fails.
+                        let _e = canvas.set_pointer_capture(pointer_id);
+
+                        ButtonSource::Mouse(button)
                    },
-                    _ => {
-                        let pointer_id = event.pointer_id();
-
-                        mouse_handler(
-                            modifiers,
-                            DeviceId::new(pointer_id),
-                            event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                            event::mouse_button(&event).expect("no mouse button pressed"),
-                        );
-
-                        if pointer_type == "mouse" {
-                            // Error is swallowed here since the error would occur every time the
-                            // mouse is clicked when the cursor is
-                            // grabbed, and there is probably not a
-                            // situation where this could fail, that we
-                            // care if it fails.
-                            let _e = canvas.set_pointer_capture(pointer_id);
-                        }
+                    PointerKind::Touch(finger_id) => ButtonSource::Touch {
+                        finger_id,
+                        force: Some(Force::Normalized(event.pressure().into())),
                    },
-                }
+                    PointerKind::Unknown => ButtonSource::Unknown(button.to_id()),
+                };
+
+                handler(
+                    modifiers,
+                    mkdid(pointer_id),
+                    event.is_primary(),
+                    event::mouse_position(&event).to_physical(super::scale_factor(&window)),
+                    source,
+                )
            }));
    }

-    pub fn on_cursor_move<M, T, B>(
+    pub fn on_pointer_move<C, B>(
        &mut self,
        canvas_common: &Common,
-        mut mouse_handler: M,
-        mut touch_handler: T,
+        mut cursor_handler: C,
        mut button_handler: B,
        prevent_default: Rc<Cell<bool>>,
    ) where
-        M: 'static
-            + FnMut(ModifiersState, DeviceId, &mut dyn Iterator<Item = PhysicalPosition<f64>>),
-        T: 'static
+        C: 'static
            + FnMut(
-                ModifiersState,
-                DeviceId,
-                FingerId,
-                &mut dyn Iterator<Item = (PhysicalPosition<f64>, Force)>,
+                Option<DeviceId>,
+                &mut dyn Iterator<
+                    Item = (ModifiersState, bool, PhysicalPosition<f64>, PointerSource),
+                >,
            ),
        B: 'static
-            + FnMut(ModifiersState, DeviceId, PhysicalPosition<f64>, ButtonsState, MouseButton),
+            + FnMut(
+                ModifiersState,
+                Option<DeviceId>,
+                bool,
+                PhysicalPosition<f64>,
+                ElementState,
+                ButtonSource,
+            ),
    {
        let window = canvas_common.window.clone();
        let canvas = canvas_common.raw().clone();
        self.on_cursor_move =
            Some(canvas_common.add_event("pointermove", move |event: PointerEvent| {
-                let modifiers = event::mouse_modifiers(&event);
                let pointer_id = event.pointer_id();
-                let device_id = DeviceId::new(pointer_id);
+                let device_id = mkdid(pointer_id);
+                let kind = event::pointer_type(&event, pointer_id);
+                let primary = event.is_primary();

                // chorded button event
                if let Some(button) = event::mouse_button(&event) {
@@ -200,11 +197,35 @@ impl PointerHandler {
                        let _ = canvas.focus();
                    }

+                    let state = if event::mouse_buttons(&event).contains(button.into()) {
+                        ElementState::Pressed
+                    } else {
+                        ElementState::Released
+                    };
+
+                    let button = match kind {
+                        PointerKind::Mouse => ButtonSource::Mouse(button),
+                        PointerKind::Touch(finger_id) => {
+                            let button_id = button.to_id();
+
+                            if button_id != 1 {
+                                tracing::error!("unexpected touch button id: {button_id}");
+                            }
+
+                            ButtonSource::Touch {
+                                finger_id,
+                                force: Some(Force::Normalized(event.pressure().into())),
+                            }
+                        },
+                        PointerKind::Unknown => todo!(),
+                    };
+
                    button_handler(
-                        modifiers,
+                        event::mouse_modifiers(&event),
                        device_id,
+                        primary,
                        event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                        event::mouse_buttons(&event),
+                        state,
                        button,
                    );

@@ -213,44 +234,25 @@ impl PointerHandler {

                // pointer move event
                let scale = super::scale_factor(&window);
-                match event.pointer_type().as_str() {
-                    "touch" => touch_handler(
-                        modifiers,
-                        device_id,
-                        FingerId::new(pointer_id, event.is_primary()),
-                        &mut event::pointer_move_event(event).map(|event| {
-                            (
-                                event::mouse_position(&event).to_physical(scale),
-                                Force::Normalized(event.pressure() as f64),
-                            )
-                        }),
-                    ),
-                    _ => mouse_handler(
-                        modifiers,
-                        device_id,
-                        &mut event::pointer_move_event(event)
-                            .map(|event| event::mouse_position(&event).to_physical(scale)),
-                    ),
-                };
-            }));
-    }

-    pub fn on_touch_cancel<F>(&mut self, canvas_common: &Common, mut handler: F)
-    where
-        F: 'static + FnMut(DeviceId, FingerId, PhysicalPosition<f64>, Force),
-    {
-        let window = canvas_common.window.clone();
-        self.on_touch_cancel =
-            Some(canvas_common.add_event("pointercancel", move |event: PointerEvent| {
-                if event.pointer_type() == "touch" {
-                    let pointer_id = event.pointer_id();
-                    handler(
-                        DeviceId::new(pointer_id),
-                        FingerId::new(pointer_id, event.is_primary()),
-                        event::mouse_position(&event).to_physical(super::scale_factor(&window)),
-                        Force::Normalized(event.pressure() as f64),
-                    );
-                }
+                cursor_handler(
+                    device_id,
+                    &mut event::pointer_move_event(event).map(|event| {
+                        (
+                            event::mouse_modifiers(&event),
+                            event.is_primary(),
+                            event::mouse_position(&event).to_physical(scale),
+                            match kind {
+                                PointerKind::Mouse => PointerSource::Mouse,
+                                PointerKind::Touch(finger_id) => PointerSource::Touch {
+                                    finger_id,
+                                    force: Some(Force::Normalized(event.pressure().into())),
+                                },
+                                PointerKind::Unknown => PointerSource::Unknown,
+                            },
+                        )
+                    }),
+                );
            }));
    }

--- a/src/platform_impl/web/web_sys/safe_area.rs
+++ b/src/platform_impl/web/web_sys/safe_area.rs
@@ -0,0 +1,56 @@
+use dpi::{LogicalPosition, LogicalSize};
+use wasm_bindgen::JsCast;
+use web_sys::{Document, HtmlHtmlElement, Window};
+
+use super::Style;
+
+pub struct SafeAreaHandle {
+    style: Style,
+}
+
+impl SafeAreaHandle {
+    pub fn new(window: &Window, document: &Document) -> Self {
+        let document: HtmlHtmlElement = document.document_element().unwrap().unchecked_into();
+        #[allow(clippy::disallowed_methods)]
+        let write = document.style();
+        write
+            .set_property(
+                "--__winit_safe_area",
+                "env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) \
+                 env(safe-area-inset-left)",
+            )
+            .expect("unexpected read-only declaration block");
+        #[allow(clippy::disallowed_methods)]
+        let read = window
+            .get_computed_style(&document)
+            .expect("failed to obtain computed style")
+            // this can't fail: we aren't using a pseudo-element
+            .expect("invalid pseudo-element");
+
+        SafeAreaHandle { style: Style { read, write } }
+    }
+
+    pub fn get(&self) -> (LogicalPosition<f64>, LogicalSize<f64>) {
+        let value = self.style.get("--__winit_safe_area");
+
+        let mut values = value
+            .split(' ')
+            .map(|value| value.strip_suffix("px").expect("unexpected unit other then `px` found"));
+        let top: f64 = values.next().unwrap().parse().unwrap();
+        let right: f64 = values.next().unwrap().parse().unwrap();
+        let bottom: f64 = values.next().unwrap().parse().unwrap();
+        let left: f64 = values.next().unwrap().parse().unwrap();
+        assert_eq!(values.next(), None, "unexpected fifth value");
+
+        let width = super::style_size_property(&self.style, "width") - left - right;
+        let height = super::style_size_property(&self.style, "height") - top - bottom;
+
+        (LogicalPosition::new(left, top), LogicalSize::new(width, height))
+    }
+}
+
+impl Drop for SafeAreaHandle {
+    fn drop(&mut self) {
+        self.style.remove("--__winit_safe_area");
+    }
+}
--- a/src/platform_impl/web/window.rs
+++ b/src/platform_impl/web/window.rs
@@ -2,19 +2,20 @@ use std::cell::Ref;
 use std::rc::Rc;
 use std::sync::Arc;

+use dpi::{LogicalPosition, LogicalSize};
 use web_sys::HtmlCanvasElement;

 use super::main_thread::{MainThreadMarker, MainThreadSafe};
 use super::monitor::MonitorHandler;
 use super::r#async::Dispatcher;
 use super::{backend, lock, ActiveEventLoop};
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{LogicalInsets, PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::icon::Icon;
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::window::{
    Cursor, CursorGrabMode, Fullscreen as RootFullscreen, ImePurpose, ResizeDirection, Theme,
-    UserAttentionType, Window as RootWindow, WindowAttributes, WindowButtons, WindowId as RootWI,
+    UserAttentionType, Window as RootWindow, WindowAttributes, WindowButtons, WindowId,
    WindowLevel,
 };

@@ -26,6 +27,7 @@ pub struct Inner {
    id: WindowId,
    pub window: web_sys::Window,
    monitor: Rc<MonitorHandler>,
+    safe_area: Rc<backend::SafeAreaHandle>,
    canvas: Rc<backend::Canvas>,
    destroy_fn: Option<Box<dyn FnOnce()>>,
 }
@@ -53,19 +55,20 @@ impl Window {
        target.register(&canvas, id);

        let runner = target.runner.clone();
-        let destroy_fn = Box::new(move || runner.notify_destroy_window(RootWI(id)));
+        let destroy_fn = Box::new(move || runner.notify_destroy_window(id));

        let inner = Inner {
            id,
            window: window.clone(),
            monitor: Rc::clone(target.runner.monitor()),
+            safe_area: Rc::clone(target.runner.safe_area()),
            canvas,
            destroy_fn: Some(destroy_fn),
        };

        let canvas = Rc::downgrade(&inner.canvas);
        let (dispatcher, runner) = Dispatcher::new(target.runner.main_thread(), inner);
-        target.runner.add_canvas(RootWI(id), canvas, runner);
+        target.runner.add_canvas(id, canvas, runner);

        Ok(Window { inner: dispatcher })
    }
@@ -91,8 +94,8 @@ impl Window {
 }

 impl RootWindow for Window {
-    fn id(&self) -> RootWI {
-        RootWI(self.inner.queue(|inner| inner.id))
+    fn id(&self) -> WindowId {
+        self.inner.queue(|inner| inner.id)
    }

    fn scale_factor(&self) -> f64 {
@@ -109,9 +112,9 @@ impl RootWindow for Window {
        // Not supported
    }

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        // Note: the canvas element has no window decorations, so this is equal to `outer_position`.
-        self.outer_position()
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        // Note: the canvas element has no window decorations.
+        (0, 0).into()
    }

    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
@@ -152,6 +155,34 @@ impl RootWindow for Window {
        self.surface_size()
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        self.inner.queue(|inner| {
+            let (safe_start_pos, safe_size) = inner.safe_area.get();
+            let safe_end_pos = LogicalPosition::new(
+                safe_start_pos.x + safe_size.width,
+                safe_start_pos.y + safe_size.height,
+            );
+
+            let surface_start_pos = inner.canvas.position();
+            let surface_size = LogicalSize::new(
+                backend::style_size_property(inner.canvas.style(), "width"),
+                backend::style_size_property(inner.canvas.style(), "height"),
+            );
+            let surface_end_pos = LogicalPosition::new(
+                surface_start_pos.x + surface_size.width,
+                surface_start_pos.y + surface_size.height,
+            );
+
+            let top = f64::max(safe_start_pos.y - surface_start_pos.y, 0.);
+            let left = f64::max(safe_start_pos.x - surface_start_pos.x, 0.);
+            let bottom = f64::max(surface_end_pos.y - safe_end_pos.y, 0.);
+            let right = f64::max(surface_end_pos.x - safe_end_pos.x, 0.);
+
+            let insets = LogicalInsets::new(top, left, bottom, right);
+            insets.to_physical(inner.scale_factor())
+        })
+    }
+
    fn set_min_surface_size(&self, min_size: Option<Size>) {
        self.inner.dispatch(move |inner| {
            let dimensions = min_size.map(|min_size| min_size.to_logical(inner.scale_factor()));
@@ -375,18 +406,15 @@ impl RootWindow for Window {
        self.inner.queue(|inner| inner.monitor.primary_monitor()).map(RootMonitorHandle::from)
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        MainThreadMarker::new()
@@ -408,7 +436,6 @@ impl rwh_06::HasWindowHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        Ok(rwh_06::DisplayHandle::web())
@@ -429,27 +456,6 @@ impl Drop for Inner {
        }
    }
 }
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(pub(crate) u32);
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        Self(0)
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0 as u64
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self(raw_id as u32)
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct PlatformSpecificWindowAttributes {
    pub(crate) canvas: Option<Arc<MainThreadSafe<backend::RawCanvasType>>>,
--- a/src/platform_impl/windows/drop_handler.rs
+++ b/src/platform_impl/windows/drop_handler.rs
@@ -15,8 +15,7 @@ use crate::event::Event;
 use crate::platform_impl::platform::definitions::{
    IDataObjectVtbl, IDropTarget, IDropTargetVtbl, IUnknownVtbl,
 };
-use crate::platform_impl::platform::WindowId;
-use crate::window::WindowId as RootWindowId;
+use crate::window::WindowId;

 #[repr(C)]
 pub struct FileDropHandlerData {
@@ -86,7 +85,7 @@ impl FileDropHandler {
        let hdrop = unsafe {
            Self::iterate_filenames(pDataObj, |filename| {
                drop_handler.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(drop_handler.window)),
+                    window_id: WindowId::from_raw(drop_handler.window as usize),
                    event: HoveredFile(filename),
                });
            })
@@ -120,7 +119,7 @@ impl FileDropHandler {
        let drop_handler = unsafe { Self::from_interface(this) };
        if drop_handler.hovered_is_valid {
            drop_handler.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(drop_handler.window)),
+                window_id: WindowId::from_raw(drop_handler.window as usize),
                event: HoveredFileCancelled,
            });
        }
@@ -140,7 +139,7 @@ impl FileDropHandler {
        let hdrop = unsafe {
            Self::iterate_filenames(pDataObj, |filename| {
                drop_handler.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(drop_handler.window)),
+                    window_id: WindowId::from_raw(drop_handler.window as usize),
                    event: DroppedFile(filename),
                });
            })
--- a/src/platform_impl/windows/event_loop.rs
+++ b/src/platform_impl/windows/event_loop.rs
--- a/src/platform_impl/windows/event_loop/runner.rs
+++ b/src/platform_impl/windows/event_loop/runner.rs
@@ -53,7 +53,7 @@ pub(crate) enum RunnerState {

 enum BufferedEvent {
    Event(Event),
-    ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
+    ScaleFactorChanged(HWND, f64, PhysicalSize<u32>),
 }

 impl EventLoopRunner {
@@ -248,9 +248,8 @@ impl EventLoopRunner {
        }
    }

-    /// Dispatch control flow events (`NewEvents`, `AboutToWait`, and
-    /// `LoopExiting`) as necessary to bring the internal `RunnerState` to the
-    /// new runner state.
+    /// Dispatch control flow events (`new_events`, `about_to_wait`) as necessary to bring the
+    /// internal `RunnerState` to the new runner state.
    ///
    /// The state transitions are defined as follows:
    ///
@@ -294,7 +293,6 @@ impl EventLoopRunner {
                self.call_new_events(true);
                self.call_event_handler(Event::AboutToWait);
                self.last_events_cleared.set(Instant::now());
-                self.call_event_handler(Event::LoopExiting);
            },
            (_, Uninitialized) => panic!("cannot move state to Uninitialized"),

@@ -302,9 +300,7 @@ impl EventLoopRunner {
            (Idle, HandlingMainEvents) => {
                self.call_new_events(false);
            },
-            (Idle, Destroyed) => {
-                self.call_event_handler(Event::LoopExiting);
-            },
+            (Idle, Destroyed) => {},

            (HandlingMainEvents, Idle) => {
                // This is always the last event we dispatch before waiting for new events
@@ -314,7 +310,6 @@ impl EventLoopRunner {
            (HandlingMainEvents, Destroyed) => {
                self.call_event_handler(Event::AboutToWait);
                self.last_events_cleared.set(Instant::now());
-                self.call_event_handler(Event::LoopExiting);
            },

            (Destroyed, _) => panic!("cannot move state from Destroyed"),
@@ -360,7 +355,7 @@ impl BufferedEvent {
                event: WindowEvent::ScaleFactorChanged { scale_factor, surface_size_writer },
                window_id,
            } => BufferedEvent::ScaleFactorChanged(
-                window_id,
+                window_id.into_raw() as HWND,
                scale_factor,
                *surface_size_writer.new_surface_size.upgrade().unwrap().lock().unwrap(),
            ),
@@ -371,10 +366,10 @@ impl BufferedEvent {
    pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
        match self {
            Self::Event(event) => dispatch(event),
-            Self::ScaleFactorChanged(window_id, scale_factor, new_surface_size) => {
+            Self::ScaleFactorChanged(window, scale_factor, new_surface_size) => {
                let user_new_surface_size = Arc::new(Mutex::new(new_surface_size));
                dispatch(Event::WindowEvent {
-                    window_id,
+                    window_id: WindowId::from_raw(window as usize),
                    event: WindowEvent::ScaleFactorChanged {
                        scale_factor,
                        surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(
@@ -388,12 +383,11 @@ impl BufferedEvent {

                if surface_size != new_surface_size {
                    let window_flags = unsafe {
-                        let userdata =
-                            get_window_long(window_id.0.into(), GWL_USERDATA) as *mut WindowData;
+                        let userdata = get_window_long(window, GWL_USERDATA) as *mut WindowData;
                        (*userdata).window_state_lock().window_flags
                    };

-                    window_flags.set_size((window_id.0).0, surface_size);
+                    window_flags.set_size(window, surface_size);
                }
            },
        }
--- a/src/platform_impl/windows/keyboard.rs
+++ b/src/platform_impl/windows/keyboard.rs
@@ -97,7 +97,7 @@ impl KeyEventBuilder {
                    MatchResult::MessagesToDispatch(self.pending.complete_multi(key_events))
                },
                WM_KILLFOCUS => {
-                    // sythesize keyup events
+                    // synthesize keyup events
                    let kbd_state = get_kbd_state();
                    let key_events = Self::synthesize_kbd_state(ElementState::Released, &kbd_state);
                    MatchResult::MessagesToDispatch(self.pending.complete_multi(key_events))
@@ -333,11 +333,11 @@ impl KeyEventBuilder {
        // We are synthesizing the press event for caps-lock first for the following reasons:
        // 1. If caps-lock is *not* held down but *is* active, then we have to synthesize all
        //    printable keys, respecting the caps-lock state.
-        // 2. If caps-lock is held down, we could choose to sythesize its keypress after every other
-        //    key, in which case all other keys *must* be sythesized as if the caps-lock state was
-        //    be the opposite of what it currently is.
+        // 2. If caps-lock is held down, we could choose to synthesize its keypress after every
+        //    other key, in which case all other keys *must* be sythesized as if the caps-lock state
+        //    was be the opposite of what it currently is.
        // --
-        // For the sake of simplicity we are choosing to always sythesize
+        // For the sake of simplicity we are choosing to always synthesize
        // caps-lock first, and always use the current caps-lock state
        // to determine the produced text
        if is_key_pressed!(VK_CAPITAL) {
@@ -1079,6 +1079,20 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
        KeyCode::AudioVolumeDown => Some(0xe02e),
        KeyCode::AudioVolumeMute => Some(0xe020),
        KeyCode::AudioVolumeUp => Some(0xe030),
+
+        // Extra from Chromium sources:
+        // https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
+        KeyCode::Lang4 => Some(0x0077),
+        KeyCode::Lang3 => Some(0x0078),
+        KeyCode::Undo => Some(0xe008),
+        KeyCode::Paste => Some(0xe00a),
+        KeyCode::Cut => Some(0xe017),
+        KeyCode::Copy => Some(0xe018),
+        KeyCode::Eject => Some(0xe02c),
+        KeyCode::Help => Some(0xe03b),
+        KeyCode::Sleep => Some(0xe05f),
+        KeyCode::WakeUp => Some(0xe063),
+
        _ => None,
    }
 }
@@ -1238,6 +1252,20 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        0xe02e => KeyCode::AudioVolumeDown,
        0xe020 => KeyCode::AudioVolumeMute,
        0xe030 => KeyCode::AudioVolumeUp,
+
+        // Extra from Chromium sources:
+        // https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
+        0x0077 => KeyCode::Lang4,
+        0x0078 => KeyCode::Lang3,
+        0xe008 => KeyCode::Undo,
+        0xe00a => KeyCode::Paste,
+        0xe017 => KeyCode::Cut,
+        0xe018 => KeyCode::Copy,
+        0xe02c => KeyCode::Eject,
+        0xe03b => KeyCode::Help,
+        0xe05f => KeyCode::Sleep,
+        0xe063 => KeyCode::WakeUp,
+
        _ => return PhysicalKey::Unidentified(NativeKeyCode::Windows(scancode as u16)),
    })
 }
--- a/src/platform_impl/windows/mod.rs
+++ b/src/platform_impl/windows/mod.rs
@@ -1,17 +1,15 @@
 use smol_str::SmolStr;
-use windows_sys::Win32::Foundation::{HANDLE, HWND};
+use windows_sys::Win32::Foundation::HWND;
 use windows_sys::Win32::UI::WindowsAndMessaging::{HMENU, WINDOW_LONG_PTR_INDEX};

-pub(crate) use self::event_loop::{
-    EventLoop, EventLoopProxy, OwnedDisplayHandle, PlatformSpecificEventLoopAttributes,
-};
+pub(crate) use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
 pub use self::icon::WinIcon as PlatformIcon;
 pub(crate) use self::icon::{SelectedCursor, WinCursor as PlatformCustomCursor, WinIcon};
 pub(crate) use self::keyboard::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
 pub(crate) use self::window::Window;
 pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::event::DeviceId as RootDeviceId;
+use crate::event::DeviceId;
 use crate::icon::Icon;
 use crate::keyboard::Key;
 use crate::platform::windows::{BackdropType, Color, CornerPreference};
@@ -59,48 +57,8 @@ impl Default for PlatformSpecificWindowAttributes {
 unsafe impl Send for PlatformSpecificWindowAttributes {}
 unsafe impl Sync for PlatformSpecificWindowAttributes {}

-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId(u32);
-
-impl DeviceId {
-    pub const 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 HANDLE)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FingerId {
-    id: u32,
-    primary: bool,
-}
-
-impl FingerId {
-    pub const fn dummy() -> Self {
-        FingerId { id: 0, primary: false }
-    }
-}
-
-impl FingerId {
-    pub fn is_primary(self) -> bool {
-        self.primary
-    }
-}
-
-// 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))
+fn wrap_device_id(id: u32) -> DeviceId {
+    DeviceId::from_raw(id as i64)
 }

 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -109,35 +67,6 @@ pub struct KeyEventExtra {
    pub key_without_modifiers: Key,
 }

-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(HWND);
-unsafe impl Send for WindowId {}
-unsafe impl Sync for WindowId {}
-
-impl WindowId {
-    pub const fn dummy() -> Self {
-        WindowId(0)
-    }
-}
-
-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0 as u64
-    }
-}
-
-impl From<WindowId> for HWND {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self(raw_id as HWND)
-    }
-}
-
 #[inline(always)]
 const fn get_xbutton_wparam(x: u32) -> u16 {
    hiword(x)
@@ -203,6 +132,6 @@ mod ime;
 mod keyboard;
 mod keyboard_layout;
 mod monitor;
-mod raw_input;
+pub(crate) mod raw_input;
 mod window;
 mod window_state;
--- a/src/platform_impl/windows/util.rs
+++ b/src/platform_impl/windows/util.rs
@@ -14,7 +14,7 @@ use windows_sys::Win32::UI::HiDpi::{
    DPI_AWARENESS_CONTEXT, MONITOR_DPI_TYPE, PROCESS_DPI_AWARENESS,
 };
 use windows_sys::Win32::UI::Input::KeyboardAndMouse::GetActiveWindow;
-use windows_sys::Win32::UI::Input::Pointer::{POINTER_INFO, POINTER_PEN_INFO, POINTER_TOUCH_INFO};
+use windows_sys::Win32::UI::Input::Pointer::{POINTER_INFO, POINTER_TOUCH_INFO};
 use windows_sys::Win32::UI::WindowsAndMessaging::{
    ClipCursor, GetClientRect, GetClipCursor, GetSystemMetrics, GetWindowPlacement, GetWindowRect,
    IsIconic, ShowCursor, IDC_APPSTARTING, IDC_ARROW, IDC_CROSS, IDC_HAND, IDC_HELP, IDC_IBEAM,
@@ -244,9 +244,6 @@ pub type GetPointerDeviceRects = unsafe extern "system" fn(
 pub type GetPointerTouchInfo =
    unsafe extern "system" fn(pointerId: u32, touchInfo: *mut POINTER_TOUCH_INFO) -> BOOL;

-pub type GetPointerPenInfo =
-    unsafe extern "system" fn(pointId: u32, penInfo: *mut POINTER_PEN_INFO) -> BOOL;
-
 pub(crate) static GET_DPI_FOR_WINDOW: Lazy<Option<GetDpiForWindow>> =
    Lazy::new(|| get_function!("user32.dll", GetDpiForWindow));
 pub(crate) static ADJUST_WINDOW_RECT_EX_FOR_DPI: Lazy<Option<AdjustWindowRectExForDpi>> =
@@ -269,5 +266,3 @@ pub(crate) static GET_POINTER_DEVICE_RECTS: Lazy<Option<GetPointerDeviceRects>>
    Lazy::new(|| get_function!("user32.dll", GetPointerDeviceRects));
 pub(crate) static GET_POINTER_TOUCH_INFO: Lazy<Option<GetPointerTouchInfo>> =
    Lazy::new(|| get_function!("user32.dll", GetPointerTouchInfo));
-pub(crate) static GET_POINTER_PEN_INFO: Lazy<Option<GetPointerPenInfo>> =
-    Lazy::new(|| get_function!("user32.dll", GetPointerPenInfo));
--- a/src/platform_impl/windows/window.rs
+++ b/src/platform_impl/windows/window.rs
@@ -46,7 +46,7 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
 };

 use crate::cursor::Cursor;
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::icon::Icon;
 use crate::monitor::MonitorHandle as CoreMonitorHandle;
@@ -66,11 +66,11 @@ use crate::platform_impl::platform::keyboard::KeyEventBuilder;
 use crate::platform_impl::platform::window_state::{
    CursorFlags, SavedWindow, WindowFlags, WindowState,
 };
-use crate::platform_impl::platform::{monitor, util, Fullscreen, SelectedCursor, WindowId};
+use crate::platform_impl::platform::{monitor, util, Fullscreen, SelectedCursor};
 use crate::window::{
    CursorGrabMode, Fullscreen as CoreFullscreen, ImePurpose, ResizeDirection, Theme,
-    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons,
-    WindowId as CoreWindowId, WindowLevel,
+    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
+    WindowLevel,
 };

 /// The Win32 implementation of the main `Window` object.
@@ -106,7 +106,6 @@ impl Window {
        self.window
    }

-    #[cfg(feature = "rwh_06")]
    pub unsafe fn rwh_06_no_thread_check(
        &self,
    ) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
@@ -119,7 +118,6 @@ impl Window {
        Ok(rwh_06::RawWindowHandle::Win32(window_handle))
    }

-    #[cfg(feature = "rwh_06")]
    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
        // TODO: Write a test once integration framework is ready to ensure that it holds.
        // If we aren't in the GUI thread, we can't return the window.
@@ -132,7 +130,6 @@ impl Window {
        unsafe { self.rwh_06_no_thread_check() }
    }

-    #[cfg(feature = "rwh_06")]
    pub fn raw_display_handle_rwh_06(
        &self,
    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
@@ -349,7 +346,6 @@ impl Drop for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_display_handle_rwh_06()?;
@@ -357,7 +353,6 @@ impl rwh_06::HasDisplayHandle for Window {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        let raw = self.raw_window_handle_rwh_06()?;
@@ -421,15 +416,15 @@ impl CoreWindow for Window {
            )
    }

-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
-        let mut position: POINT = unsafe { mem::zeroed() };
-        if unsafe { ClientToScreen(self.hwnd(), &mut position) } == false.into() {
+    fn surface_position(&self) -> PhysicalPosition<i32> {
+        let mut rect: RECT = unsafe { mem::zeroed() };
+        if unsafe { GetClientRect(self.hwnd(), &mut rect) } == false.into() {
            panic!(
-                "Unexpected ClientToScreen failure: please report this error to \
+                "Unexpected GetClientRect failure: please report this error to \
                 rust-windowing/winit"
            )
        }
-        Ok(PhysicalPosition::new(position.x, position.y))
+        PhysicalPosition::new(rect.left, rect.top)
    }

    fn set_outer_position(&self, position: Position) {
@@ -499,6 +494,10 @@ impl CoreWindow for Window {
        None
    }

+    fn safe_area(&self) -> PhysicalInsets<u32> {
+        PhysicalInsets::new(0, 0, 0, 0)
+    }
+
    fn set_min_surface_size(&self, size: Option<Size>) {
        self.window_state_lock().min_size = size;
        // Make windows re-check the window size bounds.
@@ -696,8 +695,8 @@ impl CoreWindow for Window {
        Ok(())
    }

-    fn id(&self) -> CoreWindowId {
-        CoreWindowId(WindowId(self.hwnd()))
+    fn id(&self) -> WindowId {
+        WindowId::from_raw(self.hwnd() as usize)
    }

    fn set_minimized(&self, minimized: bool) {
@@ -1054,12 +1053,10 @@ impl CoreWindow for Window {
        }
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
        self
    }

-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
        self
    }
@@ -1074,7 +1071,7 @@ pub(super) struct InitData<'a> {
    pub window: Option<Window>,
 }

-impl<'a> InitData<'a> {
+impl InitData<'_> {
    unsafe fn create_window(&self, window: HWND) -> Window {
        // Register for touch events if applicable
        {
@@ -1288,7 +1285,6 @@ unsafe fn init(
        },
    };

-    #[cfg(feature = "rwh_06")]
    let parent = match attributes.parent_window.as_ref().map(|handle| handle.0) {
        Some(rwh_06::RawWindowHandle::Win32(handle)) => {
            window_flags.set(WindowFlags::CHILD, true);
@@ -1301,9 +1297,6 @@ unsafe fn init(
        None => fallback_parent(),
    };

-    #[cfg(not(feature = "rwh_06"))]
-    let parent = fallback_parent();
-
    let menu = attributes.platform_specific.menu;
    let fullscreen = attributes.fullscreen.clone();
    let maximized = attributes.maximized;
--- a/src/window.rs
+++ b/src/window.rs
@@ -7,11 +7,11 @@ pub use cursor_icon::{CursorIcon, ParseError as CursorIconParseError};
 use serde::{Deserialize, Serialize};

 pub use crate::cursor::{BadImage, Cursor, CustomCursor, CustomCursorSource, MAX_CURSOR_SIZE};
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::RequestError;
 pub use crate::icon::{BadIcon, Icon};
 use crate::monitor::{MonitorHandle, VideoModeHandle};
-use crate::platform_impl::{self, PlatformSpecificWindowAttributes};
+use crate::platform_impl::PlatformSpecificWindowAttributes;
 use crate::utils::AsAny;

 /// Identifier of a window. Unique for each window.
@@ -21,18 +21,21 @@ use crate::utils::AsAny;
 /// Whenever you receive an event specific to a window, this event contains a `WindowId` which you
 /// can then compare to the ids of your windows.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(pub(crate) platform_impl::WindowId);
+pub struct WindowId(usize);

 impl WindowId {
-    /// Returns a dummy id, useful for unit testing.
+    /// Convert the `WindowId` into the underlying integer.
    ///
-    /// # Notes
+    /// This is useful if you need to pass the ID across an FFI boundary, or store it in an atomic.
+    pub const fn into_raw(self) -> usize {
+        self.0
+    }
+
+    /// Construct a `WindowId` from the underlying integer.
    ///
-    /// The only guarantee made about the return value of this function is that
-    /// it will always be equal to itself and to future values returned by this function.
-    /// No other guarantees are made. This may be equal to a real [`WindowId`].
-    pub const fn dummy() -> Self {
-        WindowId(platform_impl::WindowId::dummy())
+    /// This should only be called with integers returned from [`WindowId::into_raw`].
+    pub const fn from_raw(id: usize) -> Self {
+        Self(id)
    }
 }

@@ -42,18 +45,6 @@ impl fmt::Debug for WindowId {
    }
 }

-impl From<WindowId> for u64 {
-    fn from(window_id: WindowId) -> Self {
-        window_id.0.into()
-    }
-}
-
-impl From<u64> for WindowId {
-    fn from(raw_id: u64) -> Self {
-        Self(raw_id.into())
-    }
-}
-
 /// Attributes used when creating a window.
 #[derive(Debug, Clone, PartialEq)]
 pub struct WindowAttributes {
@@ -76,7 +67,6 @@ pub struct WindowAttributes {
    pub window_level: WindowLevel,
    pub active: bool,
    pub cursor: Cursor,
-    #[cfg(feature = "rwh_06")]
    pub(crate) parent_window: Option<SendSyncRawWindowHandle>,
    pub fullscreen: Option<Fullscreen>,
    // Platform-specific configuration.
@@ -107,7 +97,6 @@ impl Default for WindowAttributes {
            preferred_theme: None,
            content_protected: false,
            cursor: Cursor::default(),
-            #[cfg(feature = "rwh_06")]
            parent_window: None,
            active: true,
            platform_specific: Default::default(),
@@ -122,17 +111,13 @@ impl Default for WindowAttributes {
 /// The user has to account for that when using [`WindowAttributes::with_parent_window()`],
 /// which is `unsafe`.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg(feature = "rwh_06")]
 pub(crate) struct SendSyncRawWindowHandle(pub(crate) rwh_06::RawWindowHandle);

-#[cfg(feature = "rwh_06")]
 unsafe impl Send for SendSyncRawWindowHandle {}
-#[cfg(feature = "rwh_06")]
 unsafe impl Sync for SendSyncRawWindowHandle {}

 impl WindowAttributes {
    /// Get the parent window stored on the attributes.
-    #[cfg(feature = "rwh_06")]
    pub fn parent_window(&self) -> Option<&rwh_06::RawWindowHandle> {
        self.parent_window.as_ref().map(|handle| &handle.0)
    }
@@ -418,7 +403,6 @@ impl WindowAttributes {
    ///   <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
    /// - **X11**: A child window is confined to the client area of its parent window.
    /// - **Android / iOS / Wayland / Web:** Unsupported.
-    #[cfg(feature = "rwh_06")]
    #[inline]
    pub unsafe fn with_parent_window(
        mut self,
@@ -590,41 +574,51 @@ pub trait Window: AsAny + Send + Sync {
    // extension trait
    fn reset_dead_keys(&self);

-    /// Returns the position of the top-left hand corner of the window's client area relative to the
-    /// top-left hand corner of the desktop.
+    /// The position of the top-left hand corner of the surface relative to the top-left hand corner
+    /// of the window.
    ///
-    /// The same conditions that apply to [`Window::outer_position`] apply to this method.
+    /// This, combined with [`outer_position`], can be useful for calculating the position of the
+    /// surface relative to the desktop.
    ///
-    /// ## Platform-specific
+    /// This may also be useful for figuring out the size of the window's decorations (such as
+    /// buttons, title, etc.), but may also not correspond to that (e.g. if the title bar is made
+    /// transparent using [`with_titlebar_transparent`] on macOS, or your are drawing window
+    /// decorations yourself).
    ///
-    /// - **iOS:** Returns the top left coordinates of the window's [safe area] in the screen space
-    ///   coordinate system.
-    /// - **Web:** Returns the top-left coordinates relative to the viewport. _Note: this returns
-    ///   the same value as [`Window::outer_position`]._
-    /// - **Android / Wayland:** Always returns [`RequestError::NotSupported`].
+    /// This may be negative.
    ///
-    /// [safe area]: https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
-    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError>;
+    /// If the window does not have any decorations, and the surface is in the exact same position
+    /// as the window itself, this simply returns `(0, 0)`.
+    ///
+    /// [`outer_position`]: Self::outer_position
+    #[cfg_attr(
+        any(macos_platform, docsrs),
+        doc = "[`with_titlebar_transparent`]: \
+               crate::platform::macos::WindowAttributesExtMacOS::with_titlebar_transparent"
+    )]
+    #[cfg_attr(
+        not(any(macos_platform, docsrs)),
+        doc = "[`with_titlebar_transparent`]: #only-available-on-macos"
+    )]
+    fn surface_position(&self) -> PhysicalPosition<i32>;

-    /// Returns the position of the top-left hand corner of the window relative to the
-    /// top-left hand corner of the desktop.
+    /// The position of the top-left hand corner of the window relative to the top-left hand corner
+    /// of the desktop.
    ///
    /// Note that the top-left hand corner of the desktop is not necessarily the same as
    /// the screen. If the user uses a desktop with multiple monitors, the top-left hand corner
-    /// of the desktop is the top-left hand corner of the monitor at the top-left of the desktop.
+    /// of the desktop is the top-left hand corner of the primary monitor of the desktop.
    ///
    /// The coordinates can be negative if the top-left hand corner of the window is outside
-    /// of the visible screen region.
+    /// of the visible screen region, or on another monitor than the primary.
    ///
    /// ## Platform-specific
    ///
-    /// - **iOS:** Returns the top left coordinates of the window in the screen space coordinate
-    ///   system.
    /// - **Web:** Returns the top-left coordinates relative to the viewport.
    /// - **Android / Wayland:** Always returns [`RequestError::NotSupported`].
    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError>;

-    /// Modifies the position of the window.
+    /// Sets the position of the window on the desktop.
    ///
    /// See [`Window::outer_position`] for more information about the coordinates.
    /// This automatically un-maximizes the window if it's maximized.
@@ -654,16 +648,21 @@ pub trait Window: AsAny + Send + Sync {

    /// Returns the size of the window's render-able surface.
    ///
-    /// This is the dimensions you should pass to things like Wgpu or Glutin when configuring.
+    /// This is the dimensions you should pass to things like Wgpu or Glutin when configuring the
+    /// surface for drawing. See [`WindowEvent::SurfaceResized`] for listening to changes to this
+    /// field.
+    ///
+    /// Note that to ensure that your content is not obscured by things such as notches or the title
+    /// bar, you will likely want to only draw important content inside a specific area of the
+    /// surface, see [`safe_area()`] for details.
    ///
    /// ## Platform-specific
    ///
-    /// - **iOS:** Returns the `PhysicalSize` of the window's [safe area] in screen space
-    ///   coordinates.
    /// - **Web:** Returns the size of the canvas element. Doesn't account for CSS [`transform`].
    ///
-    /// [safe area]: https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
+    /// [`WindowEvent::SurfaceResized`]: crate::event::WindowEvent::SurfaceResized
+    /// [`safe_area()`]: Window::safe_area
    fn surface_size(&self) -> PhysicalSize<u32>;

    /// Request the new size for the surface.
@@ -710,11 +709,53 @@ pub trait Window: AsAny + Send + Sync {
    ///
    /// ## Platform-specific
    ///
-    /// - **iOS:** Returns the [`PhysicalSize`] of the window in screen space coordinates.
    /// - **Web:** Returns the size of the canvas element. _Note: this returns the same value as
    ///   [`Window::surface_size`]._
    fn outer_size(&self) -> PhysicalSize<u32>;

+    /// The inset area of the surface that is unobstructed.
+    ///
+    /// On some devices, especially mobile devices, the screen is not a perfect rectangle, and may
+    /// have rounded corners, notches, bezels, and so on. When drawing your content, you usually
+    /// want to draw your background and other such unimportant content on the entire surface, while
+    /// you will want to restrict important content such as text, interactable or visual indicators
+    /// to the part of the screen that is actually visible; for this, you use the safe area.
+    ///
+    /// The safe area is a rectangle that is defined relative to the origin at the top-left corner
+    /// of the surface, and the size extending downwards to the right. The area will not extend
+    /// beyond [the bounds of the surface][Window::surface_size].
+    ///
+    /// Note that the safe area does not take occlusion from other windows into account; in a way,
+    /// it is only a "hardware"-level occlusion.
+    ///
+    /// If the entire content of the surface is visible, this returns `(0, 0, 0, 0)`.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Android / Orbital / Wayland / Windows / X11:** Unimplemented, returns `(0, 0, 0, 0)`.
+    ///
+    /// ## Examples
+    ///
+    /// Convert safe area insets to a size and a position.
+    ///
+    /// ```
+    /// use winit::dpi::{PhysicalPosition, PhysicalSize};
+    ///
+    /// # let surface_size = dpi::PhysicalSize::new(0, 0);
+    /// # #[cfg(requires_window)]
+    /// let surface_size = window.surface_size();
+    /// # let insets = dpi::PhysicalInsets::new(0, 0, 0, 0);
+    /// # #[cfg(requires_window)]
+    /// let insets = window.safe_area();
+    ///
+    /// let origin = PhysicalPosition::new(insets.left, insets.top);
+    /// let size = PhysicalSize::new(
+    ///     surface_size.width - insets.left - insets.right,
+    ///     surface_size.height - insets.top - insets.bottom,
+    /// );
+    /// ```
+    fn safe_area(&self) -> PhysicalInsets<u32>;
+
    /// Sets a minimum dimensions of the window's surface.
    ///
    /// ```no_run
@@ -987,8 +1028,8 @@ pub trait Window: AsAny + Send + Sync {
    fn set_window_icon(&self, window_icon: Option<Icon>);

    /// Set the IME cursor editing area, where the `position` is the top left corner of that area
-    /// and `size` is the size of this area starting from the position. An example of such area
-    /// could be a input field in the UI or line in the editor.
+    /// in surface coordinates and `size` is the size of this area starting from the position. An
+    /// example of such area could be a input field in the UI or line in the editor.
    ///
    /// The windowing system could place a candidate box close to that area, but try to not obscure
    /// the specified area, so the user input to it stays visible.
@@ -1021,7 +1062,8 @@ pub trait Window: AsAny + Send + Sync {
    ///
    /// ## Platform-specific
    ///
-    /// - **X11:** - area is not supported, only position.
+    /// - **X11:** Area is not supported, only position. The bottom-right corner of the provided
+    ///   area is reported as the position.
    /// - **iOS / Android / Web / Orbital:** Unsupported.
    ///
    /// [chinese]: https://support.apple.com/guide/chinese-input-method/use-the-candidate-window-cim12992/104/mac/12.0
@@ -1044,8 +1086,8 @@ pub trait Window: AsAny + Send + Sync {
    ///
    /// - **macOS:** IME must be enabled to receive text-input where dead-key sequences are
    ///   combined.
-    /// - **iOS:** This will show / hide the soft keyboard.
-    /// - **Android / Web / Orbital:** Unsupported.
+    /// - **iOS / Android:** This will show / hide the soft keyboard.
+    /// - **Web / Orbital:** Unsupported.
    /// - **X11**: Enabling IME will disable dead keys reporting during compose.
    ///
    /// [`Ime`]: crate::event::WindowEvent::Ime
@@ -1218,7 +1260,7 @@ pub trait Window: AsAny + Send + Sync {
    /// - **iOS / Android / Web:** Always returns an [`RequestError::NotSupported`].
    fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), RequestError>;

-    /// Show [window menu] at a specified position .
+    /// Show [window menu] at a specified position in surface coordinates.
    ///
    /// This is the context menu that is normally shown when interacting with
    /// the title bar. This is useful when implementing custom decorations.
@@ -1285,11 +1327,9 @@ pub trait Window: AsAny + Send + Sync {
    fn primary_monitor(&self) -> Option<MonitorHandle>;

    /// Get the raw-window-handle v0.6 display handle.
-    #[cfg(feature = "rwh_06")]
    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle;

    /// Get the raw-window-handle v0.6 window handle.
-    #[cfg(feature = "rwh_06")]
    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle;
 }

@@ -1315,14 +1355,12 @@ impl std::hash::Hash for dyn Window + '_ {
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for dyn Window + '_ {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        self.rwh_06_display_handle().display_handle()
    }
 }

-#[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for dyn Window + '_ {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        self.rwh_06_window_handle().window_handle()
--- a/typos.toml
+++ b/typos.toml
@@ -5,3 +5,6 @@ TME_LEAVE = "TME_LEAVE"             # From windows_sys::Win32::UI::Input::Keyboa
 XF86_Calculater = "XF86_Calculater" # From xkbcommon_dl::keysyms::XF86_Calculater
 ptd = "ptd"                         # From windows_sys::Win32::System::Com::FORMATETC { ptd, ..}
 requestor = "requestor"             # From x11_dl::xlib::XSelectionEvent { requestor ..}
+
+[files]
+extend-exclude = ["*.drawio"]
Author	SHA1	Message	Date
Mads Marquart	fbc6fdc30c	Add initialization closure and drop on exit	2024-12-03 13:28:52 +01:00
Mads Marquart	164bf85b5b	Windows: Add scancode conversions from Chromium sources (#4020 )	2024-12-03 11:05:22 +01:00
Mads Marquart	cfa8f027cc	AppKit/UIKit: Do not emit default state events upon window creation (#3912 ) Do not emit redundant ScaleFactorChanged, SurfaceResized and Focused.	2024-12-02 23:10:33 +01:00
Mads Marquart	2e5db75101	Linux: Align scancode conversions with Firefox (#4021 )	2024-12-02 13:38:37 +01:00
Mads Marquart	19e5bee3d1	chore: fix clippy lints	2024-12-02 14:51:26 +03:00
Hamir Mahal	fc6cf89ac0	style: simplify string formatting for readability (#4001 )	2024-11-22 22:14:11 +01:00
Mads Marquart	dbcdb6f1b4	Add safe area and document coordinate systems (#3890 ) Added `Window::safe_area`, which describes the area of the surface that is unobstructed by notches, bezels etc. The drawing code in the examples have been updated to draw a star inside the safe area, and the plain background outside of it. Also renamed `Window::inner_position` to `Window::surface_position`, and changed it to from screen coordinates to window coordinates, to better align how these coordinate systems work together. Finally, added some SVG images and documentation to describe how all of this works. This is fully implemented on macOS and iOS, and partially on the web. Co-authored-by: daxpedda <daxpedda@gmail.com>	2024-11-21 17:37:03 +01:00
Rodrigo Rivas Costa	d0c6c34eaa	x11: move up XInput2 event registration It should be done before mapping the window, or we could lose the firsst XInput2 events, such as the first FocusIn. Fixes #2841.	2024-11-21 14:04:55 +03:00
Mads Marquart	f2688d94ea	ci: fix cargo deny	2024-11-21 10:28:32 +03:00
Nico Burns	f6b20852bf	macOS: set activation policy by default if app is not bundled (#3961 )	2024-11-18 21:19:45 +01:00
Kirill Chibisov	59b1eb5410	api: make OwnedDisplayHandle wrap an opaque type This will help in case we want to linger the event loop during drop to prevent use after free in the consumers code.	2024-11-13 15:29:05 +03:00
Aaron Muir Hamilton	f781e13166	X11: Use bottom-right corner of IME cursor area as caret position XIM servers currently do not support preedit area reporting from clients and there may be no standard way to report it. Fcitx and iBus both place the candidate window descending descending from the caret, with the reported X font; but since winit does not report a font, the height of the line is assumed 0, so when we report the top left corner of the cursor area they will tend to obscure it. Taking this into account, the best default option is to report the bottom right corner of the cursor area, because it will tend not to obscure the preedit area when using `Window::set_ime_cursor_area` in the way suggested by documentation.	2024-11-13 15:13:09 +03:00
Piotr Podusowski	9f8ac8feb5	android: use show_soft_input to summon the keyboard Route it via the `Window::set_ime_allowed` like on iOS.	2024-11-13 14:43:59 +03:00
Mads Marquart	74958ecc6f	docs: add `fn main` to root examples This is not strictly required, but makes the examples a bit easier to read understand (especially since the `EventLoop` really _should_ be created inside `fn main`, and not in some random function potentially running on a random thread).	2024-11-12 16:52:48 +03:00
Kirill Chibisov	3a60cbaba5	api: make EventLoopProxy wrap an opaque type The proxy is intended to be Clone, thus use `Arc` for it internally and don't require backends for it to be `Clone`. Use `EventLoopProxyProvider` to hide the backend's proxy implementation details. Co-authored-by: daxpedda <daxpedda@gmail.com>	2024-11-12 10:56:20 +03:00
Matěj Laitl	ae4c449670	x11: fix WindowAttributesExtX11::with_x11_screen() Based on https://github.com/rust-windowing/winit/pull/3973, which should be merged first. There's an API to programmatically specify X11 screen id (override what is determined from the `DISPLAY` env variable), but it doesn't work. Seeting up X Server with 2 screens and calling `DISPLAY=:0 X11_SCREEN_ID=1 cargo run --example window` should be equivalent to calling `DISPLAY=:0.1 cargo run --example window` The latter works (and places the window on the correct screen), but the former yields `failed to create initial window: Os(OsError { line: 620, file: "src/platform_impl/linux/x11/window.rs", error: X11Error(X11Error { error_kind: Match, error_code: 8, sequence: 219, bad_value: 1319, minor_opcode: 0, major_opcode: 1, extension_name: None, request_name: Some("CreateWindow") }) })` _Here `1319` is the root window id for screen 0, which doesn't match the screen 1 that we request._ The problem is that we need to factor in the screen id when determining the parent (root) window when not explicitly set. This patch does that. --- Also: Extend the window example with X11_{SCREEN,VISUAL}_ID env variables	2024-11-06 08:30:25 -08:00
Kirill Chibisov	b2896d7408	chore: always pull raw-window-handle Winit is not useful without it and we don't provide older versions anymore.	2024-11-03 00:39:01 +03:00
Kirill Chibisov	edfb4b03f4	chore: remove platform FingerId The same as for `WindowId`.	2024-11-02 17:10:32 +03:00
Kirill Chibisov	c8c1eca3c7	api: move primary from FingerId to Pointer events Whether the pointer event is primary or not generally matters for the context where all input is done by the same event, so users can _ignore_ non-primary events since they are likely from users clicking something else with their other fingers. Having it only on a FingerId made it useless, since it's usually used to avoid multi-touch, but if you start mapping on touch event you already can track things like that yourself. Fixes #3943. Co-authored-by: daxpedda <daxpedda@gmail.com>	2024-11-02 17:10:32 +03:00
Matěj Laitl	d3207a8d76	Apply @notgull's suggestion	2024-10-29 17:54:21 -07:00
Matěj Laitl	9d347b72d9	Add changelog entry	2024-10-29 17:54:21 -07:00
Matěj Laitl	13bb51c7e0	x11: iterate only visuals from the matching screen	2024-10-29 17:54:21 -07:00
AngelicosPhosphoros	bb4aa22cf9	Improve waiting for messages on Windows Previous version used [`SetTimer`] with `GetMessageW` for waiting. The downside of UI timers like ones created by `SetTimer`, is that they may be late by up to 15-16 ms. To fix this behaviour, I added use of high resolution timers created by [`CreateWaitableTimerExW`] with the flag `CREATE_WAITABLE_TIMER_HIGH_RESOLUTION`. In my previous experience, waiting on such timers have precision of roundly 0.5 ms which is the best available on Windows at the moment. I use [`MsgWaitForMultipleObjectsEx`] to wait simultaneously for both timer and newly arriving events. Unfortunately, high resolution timers are available only since Windows 10 1803. However: 1. Win 10 is already getting to the end of support, like all previous versions, so it is OK to rely on APIs introduced in it; 2. I use `dwMilliseconds` parameter of `MsgWaitForMultipleObjectsEx` as a fallback. It should perform not worse compared to waiting for events from `SetTimer`. I also refactored code to remove event dispatching from function responsible for waiting for events. This provides more clear separations of concern and avoids unnecessary duplication of dispatching logic. After [review] from @rib, I also moved the waiting itself from `wait_for_messages` method to separate function, so it is clearly seen that `wait_for_messages` do 3 things: notify app that we about to wait, wait, notify that we have new events. I have tested behaviour using a egui app with Vulkan rendering with `VK_PRESENT_MODE_IMMEDIATE_KHR`, and older version consistently have twice less FPS than requested (e.g. 30 FPS when limit is 60 and 60 FPS when limit is 120) while newer version works more correctly (almost always 60 FPS when limit is 60, and only 5-10 frames missing when FPS is set to 120 or more). Fixes https://github.com/rust-windowing/winit/issues/1610 [`CreateWaitableTimerExW`]: https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-createwaitabletimerexw [`MsgWaitForMultipleObjectsEx`]: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-msgwaitformultipleobjectsex [`SetTimer`]: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-settimer [review]: https://github.com/rust-windowing/winit/pull/3950#discussion_r1800184479	2024-10-28 16:38:17 -07:00
Valentine Briese	3e9b80d47a	macOS: add ability to make titlebar unified (#3960 ) Adds `WindowExtMacOS::set_unified_titlebar` and `WindowAttributesExtMacOS::with_unified_titlebar`, which allow you to use a larger titlebar style on macOS.	2024-10-25 23:22:52 +02:00
Nico Burns	c913cdab0b	macOS: add a way to hook standard keybinding events Add macOS specific application handler to deliver macOS specific events. Co-authored-by: Mads Marquart <mads@marquart.dk>	2024-10-23 08:33:42 +00:00
Shane Celis	a5f5ce6a3d	macOS: fix panic during drag_window Return error from it instead of unwrapping.	2024-10-22 11:00:53 +00:00
Kirill Chibisov	fb6b1d487b	deps: bump redox-syscall to 0.5.7	2024-10-21 21:33:51 +00:00
Marijn Suijten	7d77ccfad3	android: Forward `suspended()` and `resumed()` events and patch up platform-specific documentation (#3786 ) Key them off of `onStop()` and `onStart()` which seems to match the other backends most closely. These [Android Activity lifecycle] events denote when the application is visible on-screen, and recommend that any heavy lifting for startup and shutdown happens here, as the application may be demoted to the background and later shut down entirely unless the user navigates back to it. [Android Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle	2024-10-16 12:17:59 +02:00
Kirill Chibisov	c23bed20b8	x11: don't forward key events to IME when it's disabled Fixes #3815.	2024-10-13 21:57:02 +03:00
Hiroaki Yutani	8fe2b62adf	docs: fix function name of `with_any_thread`	2024-10-13 21:34:11 +03:00
Kirill Chibisov	4e3165f3d8	chore: remove platform DeviceId The same as for `WindowId`.	2024-10-11 11:15:54 +03:00
Mads Marquart	da2268ae22	chore: remove platform WindowId's WindowId is a window _identifier_, and as such doesn't store anything (unlike a _handle_). So we can safely make only be defined once, in the core crate. There are a few backends where we still use `into_raw` internally; I consider these patterns discouraged, we should not be passing around important state in the window id.	2024-10-08 16:29:40 +03:00
daxpedda	eccd9e415d	api: overhaul pointer API - Rename `CursorMoved` to `PointerMoved`. - Rename `CursorEntered` to `PointerEntered`. - Rename `CursorLeft` to `PointerLeft`. - Rename `MouseInput` to `PointerButton`. - Add `position` to every `PointerEvent`. - Remove `Touch`, which is folded into the `Pointer*` events. - New `PointerType` added to `PointerEntered` and `PointerLeft`, signifying which pointer type is the source of this event. - New `PointerSource` added to `PointerMoved`, similar to `PointerType` but holding additional data. - New `ButtonSource` added to `PointerButton`, similar to `PointerType` but holding pointer type specific buttons. Use `ButtonSource::mouse_button()` to easily normalize any pointer button type to a generic mouse button. - In the same spirit rename `DeviceEvent::MouseMotion` to `PointerMotion`. - Remove `Force::Calibrated::altitude_angle`. Fixes #3833. Fixes #883. Fixes #336. Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2024-10-08 15:19:00 +03:00
daxpedda	32cd1ad9a7	api: remove `::dummy` from `Id` types `::dummy` was used for testing purposes and became redundant after adding e.g. `from_raw` and `into_raw` methods on `Id` types.	2024-09-29 16:49:45 +03:00
daxpedda	6e1b9fa24d	api: replace `WindowId` `From/Into` `u64` with `WindowId::{from,into}_raw()` Co-authored-by: Mads Marquart <mads@marquart.dk> Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2024-09-27 23:12:50 +03:00
Mads Marquart	380eea0072	macOS: Fix move event sometimes being triggered on resize (#3914 )	2024-09-24 01:06:10 +02:00
Kirill Chibisov	a18658284c	chore: fix nightly CI on linux/ios Co-authored-by: Mads Marquart <mads@marquart.dk>	2024-09-23 22:26:21 +03:00
Philpax	8ddd10a7f9	doc: link `DeviceEvent::MouseMotion` from cursor moved	2024-09-22 17:02:40 +03:00
John Nunley	4f1c5b6129	docs: Explicitly demarcate platform support As discussed in today's meeting, this commit creates two tiers of support. Tier 1, which is what we actively test, and Tier 2, what we hope compiles. Signed-off-by: John Nunley <dev@notgull.net> Co-authored-by: daxpedda <daxpedda@gmail.com>	2024-09-19 17:09:10 -07:00
purajit	7e819bb2ce	Prevent winit from overriding LSUIElement in package manifests (#3920 )	2024-09-16 15:49:18 +02:00
Mads Marquart	dfea49f488	Support drawing on iOS in examples Softbuffer v0.4.6 added support for iOS.	2024-09-10 17:36:04 +03:00
				`@@ -0,0 +1 @@`
				<svg xmlns="http://www.w3.org/2000/svg" width="720" height="720" viewBox="-0.5 -0.5 720 720" class="ge-export-svg-auto"><defs><style><![CDATA[@media (prefers-color-scheme:dark){svg.ge-export-svg-auto svg:not(mjx-container>svg),svg.ge-export-svg-auto:not(mjx-container>svg){filter:invert(100%) hue-rotate(180deg)}}]]></style></defs><g data-cell-id="0"><g data-cell-id="1"><rect x="200" y="40" width="320" height="640" rx="48" ry="48" fill="#e8e8e8" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-1"/><rect x="210" y="50" width="300" height="620" rx="45" ry="45" fill="#d5e8d4" stroke="#82b366" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-2"/><path fill="#ffe6cc" stroke="#d79b00" pointer-events="all" d="M210 90h300v540H210z" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-4"/><rect x="290" y="640" width="140" height="10" rx="1.5" ry="1.5" fill="#dbdbdb" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-20"/><rect x="300" y="50" width="120" height="30" rx="4.5" ry="4.5" fill="#dbdbdb" stroke="#666" pointer-events="all" data-cell-id="RxwCrVmIsQwV7z5iJ9nY-3"/><g data-cell-id="RxwCrVmIsQwV7z5iJ9nY-12"><path d="M510 50h50v620h-50" fill="none" stroke="#82b366" stroke-width="3" stroke-miterlimit="10" stroke-dasharray="9 9" pointer-events="stroke"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:360px;margin-left:575px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: #82B366;"><div style="display:inline-block;font-size:20px;font-family:"monospace";color:#82b366;line-height:1.2;pointer-events:all;white-space:nowrap"><font>surface_size</font></div></div></div></foreignObject><text x="575" y="366" fill="#82B366" font-family=""monospace"" font-size="20">surfa...</text></switch></g><g data-cell-id="NrHAzeOh65jb3hkBOxW9-1"><path d="M180 62.35v15.3" fill="none" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="stroke"/><path d="m180 53.35 3 9h-6ZM180 86.65l-3-9h6Z" fill="#d79b00" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-end;width:1px;height:1px;padding-top:70px;margin-left:165px"><div style="box-sizing:border-box;font-size:0;text-align:right" data-drawio-colors="color: #D79B00;"><div style="display:inline-block;font-size:20px;font-family:"monospace";color:#d79b00;line-height:1.2;pointer-events:all;white-space:nowrap"><div>safe_area.top</div></div></div></div></foreignObject><text x="165" y="76" fill="#D79B00" font-family=""monospace"" font-size="20" text-anchor="end">safe_...</text></switch></g><g data-cell-id="NrHAzeOh65jb3hkBOxW9-5"><path d="M180 657.65v-15.3" fill="none" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="stroke"/><path d="m180 666.65-3-9h6ZM180 633.35l3 9h-6Z" fill="#d79b00" stroke="#d79b00" stroke-width="3" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-end;width:1px;height:1px;padding-top:650px;margin-left:165px"><div style="box-sizing:border-box;font-size:0;text-align:right" data-drawio-colors="color: #D79B00;"><div style="display:inline-block;font-size:20px;font-family:"monospace";color:#d79b00;line-height:1.2;pointer-events:all;white-space:nowrap"><div>safe_area.bottom</div></div></div></div></foreignObject><text x="165" y="656" fill="#D79B00" font-family=""monospace"" font-size="20" text-anchor="end">safe_...</text></switch></g></g></g></svg>