Repository: iced-rs/iced (language: rust)

Issue:
Expose physical keys
Expose winit physical keys, aka native key codes. Useful for shortcuts that a based on actual position of keys. 

The data model basically just a copy from winit with some changes:
- `unreachable!()` in conversion function because of non_exhaustive, there is non_exhaustive_omitted_patterns lint which could help, but it is nightly-only
- removed serde feature
- added `#![allow(missing_docs)]` on top of file
- run cargo fmt with several small styling changes to make ci/cd happy 

~~Alternative would be to re-export types from winit. Let me know which one do you prefer.~~ winit is abstracted away 



Discussion / hints:

Fix patch:
diff --git a/core/src/keyboard/event.rs b/core/src/keyboard/event.rs
index 1eb4233476..26c457170a 100644
--- a/core/src/keyboard/event.rs
+++ b/core/src/keyboard/event.rs
@@ -1,3 +1,4 @@
+use crate::keyboard::key;
 use crate::keyboard::{Key, Location, Modifiers};
 use crate::SmolStr;
 
@@ -14,6 +15,12 @@ pub enum Event {
         /// The key pressed.
         key: Key,
 
+        /// The key pressed with all keyboard modifiers applied, except Ctrl.
+        modified_key: Key,
+
+        /// The physical key pressed.
+        physical_key: key::Physical,
+
         /// The location of the key.
         location: Location,
 
diff --git a/core/src/keyboard/key.rs b/core/src/keyboard/key.rs
index dbde51965c..479d999bc9 100644
--- a/core/src/keyboard/key.rs
+++ b/core/src/keyboard/key.rs
@@ -742,3 +742,536 @@ pub enum Named {
     /// General-purpose function key.
     F35,
 }
+
+/// Code representing the location of a physical key.
+///
+/// This mostly conforms to the UI Events Specification's [`KeyboardEvent.code`] with a few
+/// exceptions:
+/// - The keys that the specification calls "MetaLeft" and "MetaRight" are named "SuperLeft" and
+///   "SuperRight" here.
+/// - The key that the specification calls "Super" is reported as `Unidentified` here.
+///
+/// [`KeyboardEvent.code`]: https://w3c.github.io/uievents-code/#code-value-tables
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Code {
+    /// <kbd>`</kbd> on a US keyboard. This is also called a backtick or grave.
+    /// This is the <kbd>半角</kbd>/<kbd>全角</kbd>/<kbd>漢字</kbd>
+    /// (hankaku/zenkaku/kanji) key on Japanese keyboards
+    Backquote,
+    /// Used for both the US <kbd>\\</kbd> (on the 101-key layout) and also for the key
+    /// located between the <kbd>"</kbd> and <kbd>Enter</kbd> keys on row C of the 102-,
+    /// 104- and 106-key layouts.
+    /// Labeled <kbd>#</kbd> on a UK (102) keyboard.
+    Backslash,
+    /// <kbd>[</kbd> on a US keyboard.
+    BracketLeft,
+    /// <kbd>]</kbd> on a US keyboard.
+    BracketRight,
+    /// <kbd>,</kbd> on a US keyboard.
+    Comma,
+    /// <kbd>0</kbd> on a US keyboard.
+    Digit0,
+    /// <kbd>1</kbd> on a US keyboard.
+    Digit1,
+    /// <kbd>2</kbd> on a US keyboard.
+    Digit2,
+    /// <kbd>3</kbd> on a US keyboard.
+    Digit3,
+    /// <kbd>4</kbd> on a US keyboard.
+    Digit4,
+    /// <kbd>5</kbd> on a US keyboard.
+    Digit5,
+    /// <kbd>6</kbd> on a US keyboard.
+    Digit6,
+    /// <kbd>7</kbd> on a US keyboard.
+    Digit7,
+    /// <kbd>8</kbd> on a US keyboard.
+    Digit8,
+    /// <kbd>9</kbd> on a US keyboard.
+    Digit9,
+    /// <kbd>=</kbd> on a US keyboard.
+    Equal,
+    /// Located between the left <kbd>Shift</kbd> and <kbd>Z</kbd> keys.
+    /// Labeled <kbd>\\</kbd> on a UK keyboard.
+    IntlBackslash,
+    /// Located between the <kbd>/</kbd> and right <kbd>Shift</kbd> keys.
+    /// Labeled <kbd>\\</kbd> (ro) on a Japanese keyboard.
+    IntlRo,
+    /// Located between the <kbd>=</kbd> and <kbd>Backspace</kbd> keys.
+    /// Labeled <kbd>¥</kbd> (yen) on a Japanese keyboard. <kbd>\\</kbd> on a
+    /// Russian keyboard.
+    IntlYen,
+    /// <kbd>a</kbd> on a US keyboard.
+    /// Labeled <kbd>q</kbd> on an AZERTY (e.g., French) keyboard.
+    KeyA,
+    /// <kbd>b</kbd> on a US keyboard.
+    KeyB,
+    /// <kbd>c</kbd> on a US keyboard.
+    KeyC,
+    /// <kbd>d</kbd> on a US keyboard.
+    KeyD,
+    /// <kbd>e</kbd> on a US keyboard.
+    KeyE,
+    /// <kbd>f</kbd> on a US keyboard.
+    KeyF,
+    /// <kbd>g</kbd> on a US keyboard.
+    KeyG,
+    /// <kbd>h</kbd> on a US keyboard.
+    KeyH,
+    /// <kbd>i</kbd> on a US keyboard.
+    KeyI,
+    /// <kbd>j</kbd> on a US keyboard.
+    KeyJ,
+    /// <kbd>k</kbd> on a US keyboard.
+    KeyK,
+    /// <kbd>l</kbd> on a US keyboard.
+    KeyL,
+    /// <kbd>m</kbd> on a US keyboard.
+    KeyM,
+    /// <kbd>n</kbd> on a US keyboard.
+    KeyN,
+    /// <kbd>o</kbd> on a US keyboard.
+    KeyO,
+    /// <kbd>p</kbd> on a US keyboard.
+    KeyP,
+    /// <kbd>q</kbd> on a US keyboard.
+    /// Labeled <kbd>a</kbd> on an AZERTY (e.g., French) keyboard.
+    KeyQ,
+    /// <kbd>r</kbd> on a US keyboard.
+    KeyR,
+    /// <kbd>s</kbd> on a US keyboard.
+    KeyS,
+    /// <kbd>t</kbd> on a US keyboard.
+    KeyT,
+    /// <kbd>u</kbd> on a US keyboard.
+    KeyU,
+    /// <kbd>v</kbd> on a US keyboard.
+    KeyV,
+    /// <kbd>w</kbd> on a US keyboard.
+    /// Labeled <kbd>z</kbd> on an AZERTY (e.g., French) keyboard.
+    KeyW,
+    /// <kbd>x</kbd> on a US keyboard.
+    KeyX,
+    /// <kbd>y</kbd> on a US keyboard.
+    /// Labeled <kbd>z</kbd> on a QWERTZ (e.g., German) keyboard.
+    KeyY,
+    /// <kbd>z</kbd> on a US keyboard.
+    /// Labeled <kbd>w</kbd> on an AZERTY (e.g., French) keyboard, and <kbd>y</kbd> on a
+    /// QWERTZ (e.g., German) keyboard.
+    KeyZ,
+    /// <kbd>-</kbd> on a US keyboard.
+    Minus,
+    /// <kbd>.</kbd> on a US keyboard.
+    Period,
+    /// <kbd>'</kbd> on a US keyboard.
+    Quote,
+    /// <kbd>;</kbd> on a US keyboard.
+    Semicolon,
+    /// <kbd>/</kbd> on a US keyboard.
+    Slash,
+    /// <kbd>Alt</kbd>, <kbd>Option</kbd>, or <kbd>⌥</kbd>.
+    AltLeft,
+    /// <kbd>Alt</kbd>, <kbd>Option</kbd>, or <kbd>⌥</kbd>.
+    /// This is labeled <kbd>AltGr</kbd> on many keyboard layouts.
+    AltRight,
+    /// <kbd>Backspace</kbd> or <kbd>⌫</kbd>.
+    /// Labeled <kbd>Delete</kbd> on Apple keyboards.
+    Backspace,
+    /// <kbd>CapsLock</kbd> or <kbd>⇪</kbd>
+    CapsLock,
+    /// The application context menu key, which is typically found between the right
+    /// <kbd>Super</kbd> key and the right <kbd>Control</kbd> key.
+    ContextMenu,
+    /// <kbd>Control</kbd> or <kbd>⌃</kbd>
+    ControlLeft,
+    /// <kbd>Control</kbd> or <kbd>⌃</kbd>
+    ControlRight,
+    /// <kbd>Enter</kbd> or <kbd>↵</kbd>. Labeled <kbd>Return</kbd> on Apple keyboards.
+    Enter,
+    /// The Windows, <kbd>⌘</kbd>, <kbd>Command</kbd>, or other OS symbol key.
+    SuperLeft,
+    /// The Windows, <kbd>⌘</kbd>, <kbd>Command</kbd>, or other OS symbol key.
+    SuperRight,
+    /// <kbd>Shift</kbd> or <kbd>⇧</kbd>
+    ShiftLeft,
+    /// <kbd>Shift</kbd> or <kbd>⇧</kbd>
+    ShiftRight,
+    /// <kbd> </kbd> (space)
+    Space,
+    /// <kbd>Tab</kbd> or <kbd>⇥</kbd>
+    Tab,
+    /// Japanese: <kbd>変</kbd> (henkan)
+    Convert,
+    /// Japanese: <kbd>カタカナ</kbd>/<kbd>ひらがな</kbd>/<kbd>ローマ字</kbd>
+    /// (katakana/hiragana/romaji)
+    KanaMode,
+    /// Korean: HangulMode <kbd>한/영</kbd> (han/yeong)
+    ///
+    /// Japanese (Mac keyboard): <kbd>か</kbd> (kana)
+    Lang1,
+    /// Korean: Hanja <kbd>한</kbd> (hanja)
+    ///
+    /// Japanese (Mac keyboard): <kbd>英</kbd> (eisu)
+    Lang2,
+    /// Japanese (word-processing keyboard): Katakana
+    Lang3,
+    /// Japanese (word-processing keyboard): Hiragana
+    Lang4,
+    /// Japanese (word-processing keyboard): Zenkaku/Hankaku
+    Lang5,
+    /// Japanese: <kbd>無変換</kbd> (muhenkan)
+    NonConvert,
+    /// <kbd>⌦</kbd>. The forward delete key.
+    /// Note that on Apple keyboards, the key labelled <kbd>Delete</kbd> on the main part of
+    /// the keyboard is encoded as [`Backspace`].
+    ///
+    /// [`Backspace`]: Self::Backspace
+    Delete,
+    /// <kbd>Page Down</kbd>, <kbd>End</kbd>, or <kbd>↘</kbd>
+    End,
+    /// <kbd>Help</kbd>. Not present on standard PC keyboards.
+    Help,
+    /// <kbd>Home</kbd> or <kbd>↖</kbd>
+    Home,
+    /// <kbd>Insert</kbd> or <kbd>Ins</kbd>. Not present on Apple keyboards.
+    Insert,
+    /// <kbd>Page Down</kbd>, <kbd>PgDn</kbd>, or <kbd>⇟</kbd>
+    PageDown,
+    /// <kbd>Page Up</kbd>, <kbd>PgUp</kbd>, or <kbd>⇞</kbd>
+    PageUp,
+    /// <kbd>↓</kbd>
+    ArrowDown,
+    /// <kbd>←</kbd>
+    ArrowLeft,
+    /// <kbd>→</kbd>
+    ArrowRight,
+    /// <kbd>↑</kbd>
+    ArrowUp,
+    /// On the Mac, this is used for the numpad <kbd>Clear</kbd> key.
+    NumLock,
+    /// <kbd>0 Ins</kbd> on a keyboard. <kbd>0</kbd> on a phone or remote control
+    Numpad0,
+    /// <kbd>1 End</kbd> on a keyboard. <kbd>1</kbd> or <kbd>1 QZ</kbd> on a phone or remote
+    /// control
+    Numpad1,
+    /// <kbd>2 ↓</kbd> on a keyboard. <kbd>2 ABC</kbd> on a phone or remote control
+    Numpad2,
+    /// <kbd>3 PgDn</kbd> on a keyboard. <kbd>3 DEF</kbd> on a phone or remote control
+    Numpad3,
+    /// <kbd>4 ←</kbd> on a keyboard. <kbd>4 GHI</kbd> on a phone or remote control
+    Numpad4,
+    /// <kbd>5</kbd> on a keyboard. <kbd>5 JKL</kbd> on a phone or remote control
+    Numpad5,
+    /// <kbd>6 →</kbd> on a keyboard. <kbd>6 MNO</kbd> on a phone or remote control
+    Numpad6,
+    /// <kbd>7 Home</kbd> on a keyboard. <kbd>7 PQRS</kbd> or <kbd>7 PRS</kbd> on a phone
+    /// or remote control
+    Numpad7,
+    /// <kbd>8 ↑</kbd> on a keyboard. <kbd>8 TUV</kbd> on a phone or remote control
+    Numpad8,
+    /// <kbd>9 PgUp</kbd> on a keyboard. <kbd>9 WXYZ</kbd> or <kbd>9 WXY</kbd> on a phone
+    /// or remote control
+    Numpad9,
+    /// <kbd>+</kbd>
+    NumpadAdd,
+    /// Found on the Microsoft Natural Keyboard.
+    NumpadBackspace,
+    /// <kbd>C</kbd> or <kbd>A</kbd> (All Clear). Also for use with numpads that have a
+    /// <kbd>Clear</kbd> key that is separate from the <kbd>NumLock</kbd> key. On the Mac, the
+    /// numpad <kbd>Clear</kbd> key is encoded as [`NumLock`].
+    ///
+    /// [`NumLock`]: Self::NumLock
+    NumpadClear,
+    /// <kbd>C</kbd> (Clear Entry)
+    NumpadClearEntry,
+    /// <kbd>,</kbd> (thousands separator). For locales where the thousands separator
+    /// is a "." (e.g., Brazil), this key may generate a <kbd>.</kbd>.
+    NumpadComma,
+    /// <kbd>. Del</kbd>. For locales where the decimal separator is "," (e.g.,
+    /// Brazil), this key may generate a <kbd>,</kbd>.
+    NumpadDecimal,
+    /// <kbd>/</kbd>
+    NumpadDivide,
+    NumpadEnter,
+    /// <kbd>=</kbd>
+    NumpadEqual,
+    /// <kbd>#</kbd> on a phone or remote control device. This key is typically found
+    /// below the <kbd>9</kbd> key and to the right of the <kbd>0</kbd> key.
+    NumpadHash,
+    /// <kbd>M</kbd> Add current entry to the value stored in memory.
+    NumpadMemoryAdd,
+    /// <kbd>M</kbd> Clear the value stored in memory.
+    NumpadMemoryClear,
+    /// <kbd>M</kbd> Replace the current entry with the value stored in memory.
+    NumpadMemoryRecall,
+    /// <kbd>M</kbd> Replace the value stored in memory with the current entry.
+    NumpadMemoryStore,
+    /// <kbd>M</kbd> Subtract current entry from the value stored in memory.
+    NumpadMemorySubtract,
+    /// <kbd>*</kbd> on a keyboard. For use with numpads that provide mathematical
+    /// operations (<kbd>+</kbd>, <kbd>-</kbd> <kbd>*</kbd> and <kbd>/</kbd>).
+    ///
+    /// Use `NumpadStar` for the <kbd>*</kbd> key on phones and remote controls.
+    NumpadMultiply,
+    /// <kbd>(</kbd> Found on the Microsoft Natural Keyboard.
+    NumpadParenLeft,
+    /// <kbd>)</kbd> Found on the Microsoft Natural Keyboard.
+    NumpadParenRight,
+    /// <kbd>*</kbd> on a phone or remote control device.
+    ///
+    /// This key is typically found below the <kbd>7</kbd> key and to the left of
+    /// the <kbd>0</kbd> key.
+    ///
+    /// Use <kbd>"NumpadMultiply"</kbd> for the <kbd>*</kbd> key on
+    /// numeric keypads.
+    NumpadStar,
+    /// <kbd>-</kbd>
+    NumpadSubtract,
+    /// <kbd>Esc</kbd> or <kbd>⎋</kbd>
+    Escape,
+    /// <kbd>Fn</kbd> This is typically a hardware key that does not generate a separate code.
+    Fn,
+    /// <kbd>FLock</kbd> or <kbd>FnLock</kbd>. Function Lock key. Found on the Microsoft
+    /// Natural Keyboard.
+    FnLock,
+    /// <kbd>PrtScr SysRq</kbd> or <kbd>Print Screen</kbd>
+    PrintScreen,
+    /// <kbd>Scroll Lock</kbd>
+    ScrollLock,
+    /// <kbd>Pause Break</kbd>
+    Pause,
+    /// Some laptops place this key to the left of the <kbd>↑</kbd> key.
+    ///
+    /// This also the "back" button (triangle) on Android.
+    BrowserBack,
+    BrowserFavorites,
+    /// Some laptops place this key to the right of the <kbd>↑</kbd> key.
+    BrowserForward,
+    /// The "home" button on Android.
+    BrowserHome,
+    BrowserRefresh,
+    BrowserSearch,
+    BrowserStop,
+    /// <kbd>Eject</kbd> or <kbd>⏏</kbd>. This key is placed in the function section on some Apple
+    /// keyboards.
+    Eject,
+    /// Sometimes labelled <kbd>My Computer</kbd> on the keyboard
+    LaunchApp1,
+    /// Sometimes labelled <kbd>Calculator</kbd> on the keyboard
+    LaunchApp2,
+    LaunchMail,
+    MediaPlayPause,
+    MediaSelect,
+    MediaStop,
+    MediaTrackNext,
+    MediaTrackPrevious,
+    /// This key is placed in the function section on some Apple keyboards, replacing the
+    /// <kbd>Eject</kbd> key.
+    Power,
+    Sleep,
+    AudioVolumeDown,
+    AudioVolumeMute,
+    AudioVolumeUp,
+    WakeUp,
+    // Legacy modifier key. Also called "Super" in certain places.
+    Meta,
+    // Legacy modifier key.
+    Hyper,
+    Turbo,
+    Abort,
+    Resume,
+    Suspend,
+    /// Found on Sun’s USB keyboard.
+    Again,
+    /// Found on Sun’s USB keyboard.
+    Copy,
+    /// Found on Sun’s USB keyboard.
+    Cut,
+    /// Found on Sun’s USB keyboard.
+    Find,
+    /// Found on Sun’s USB keyboard.
+    Open,
+    /// Found on Sun’s USB keyboard.
+    Paste,
+    /// Found on Sun’s USB keyboard.
+    Props,
+    /// Found on Sun’s USB keyboard.
+    Select,
+    /// Found on Sun’s USB keyboard.
+    Undo,
+    /// Use for dedicated <kbd>ひらがな</kbd> key found on some Japanese word processing keyboards.
+    Hiragana,
+    /// Use for dedicated <kbd>カタカナ</kbd> key found on some Japanese word processing keyboards.
+    Katakana,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F1,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F2,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F3,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F4,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F5,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F6,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F7,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F8,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F9,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F10,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F11,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F12,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F13,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F14,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F15,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F16,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F17,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F18,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F19,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F20,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F21,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F22,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F23,
+    /// General-purpose function key.
+    /// Usually found at the top of the keyboard.
+    F24,
+    /// General-purpose function key.
+    F25,
+    /// General-purpose function key.
+    F26,
+    /// General-purpose function key.
+    F27,
+    /// General-purpose function key.
+    F28,
+    /// General-purpose function key.
+    F29,
+    /// General-purpose function key.
+    F30,
+    /// General-purpose function key.
+    F31,
+    /// General-purpose function key.
+    F32,
+    /// General-purpose function key.
+    F33,
+    /// General-purpose function key.
+    F34,
+    /// General-purpose function key.
+    F35,
+}
+
+/// Contains the platform-native physical key identifier.
+///
+/// The exact values vary from platform to platform (which is part of why this is a per-platform
+/// enum), but the values are primarily tied to the key's physical location on the keyboard.
+///
+/// This enum is primarily used to store raw keycodes when Winit doesn't map a given native
+/// physical key identifier to a meaningful [`Code`] variant. In the presence of identifiers we
+/// haven't mapped for you yet, this lets you use use [`Code`] to:
+///
+/// - Correctly match key press and release events.
+/// - On non-web platforms, support assigning keybinds to virtually any key through a UI.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum NativeCode {
+    /// An unidentified code.
+    Unidentified,
+    /// An Android "scancode".
+    Android(u32),
+    /// A macOS "scancode".
+    MacOS(u16),
+    /// A Windows "scancode".
+    Windows(u16),
+    /// An XKB "keycode".
+    Xkb(u32),
+}
+
+/// Represents the location of a physical key.
+///
+/// This type is a superset of [`Code`], including an [`Unidentified`][Self::Unidentified]
+/// variant.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Physical {
+    /// A known key code
+    Code(Code),
+    /// This variant is used when the key cannot be translated to a [`Code`]
+    ///
+    /// The native keycode is provided (if available) so you're able to more reliably match
+    /// key-press and key-release events by hashing the [`Physical`] key. It is also possible to use
+    /// this for keybinds for non-standard keys, but such keybinds are tied to a given platform.
+    Unidentified(NativeCode),
+}
+
+impl PartialEq<Code> for Physical {
+    #[inline]
+    fn eq(&self, rhs: &Code) -> bool {
+        match self {
+            Physical::Code(ref code) => code == rhs,
+            Physical::Unidentified(_) => false,
+        }
+    }
+}
+
+impl PartialEq<Physical> for Code {
+    #[inline]
+    fn eq(&self, rhs: &Physical) -> bool {
+        rhs == self
+    }
+}
+
+impl PartialEq<NativeCode> for Physical {
+    #[inline]
+    fn eq(&self, rhs: &NativeCode) -> bool {
+        match self {
+            Physical::Unidentified(ref code) => code == rhs,
+            Physical::Code(_) => false,
+        }
+    }
+}
+
+impl PartialEq<Physical> for NativeCode {
+    #[inline]
+    fn eq(&self, rhs: &Physical) -> bool {
+        rhs == self
+    }
+}
diff --git a/winit/src/conversion.rs b/winit/src/conversion.rs
index aaaca1a98a..13b0f15bbf 100644
--- a/winit/src/conversion.rs
+++ b/winit/src/conversion.rs
@@ -192,7 +192,7 @@ pub fn window_event(
             }
         },
         WindowEvent::KeyboardInput { event, .. } => Some(Event::Keyboard({
-            let logical_key = {
+            let key = {
                 #[cfg(not(target_arch = "wasm32"))]
                 {
                     use winit::platform::modifier_supplement::KeyEventExtModifierSupplement;
@@ -202,7 +202,7 @@ pub fn window_event(
                 #[cfg(target_arch = "wasm32")]
                 {
                     // TODO: Fix inconsistent API on Wasm
-                    event.logical_key
+                    event.logical_key.clone()
                 }
             };
 
@@ -223,9 +223,16 @@ pub fn window_event(
             }.filter(|text| !text.as_str().chars().any(is_private_use));
 
             let winit::event::KeyEvent {
-                state, location, ..
+                state,
+                location,
+                logical_key,
+                physical_key,
+                ..
             } = event;
-            let key = key(logical_key);
+
+            let key = self::key(key);
+            let modified_key = self::key(logical_key);
+            let physical_key = self::physical_key(physical_key);
             let modifiers = self::modifiers(modifiers);
 
             let location = match location {
@@ -245,6 +252,8 @@ pub fn window_event(
                 winit::event::ElementState::Pressed => {
                     keyboard::Event::KeyPressed {
                         key,
+                        modified_key,
+                        physical_key,
                         modifiers,
                         location,
                         text,
@@ -510,7 +519,7 @@ pub fn touch_event(
     }
 }
 
-/// Converts a `VirtualKeyCode` from [`winit`] to an [`iced`] key code.
+/// Converts a `Key` from [`winit`] to an [`iced`] key.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit
 /// [`iced`]: https://github.com/iced-rs/iced/tree/0.12
@@ -839,6 +848,257 @@ pub fn key(key: winit::keyboard::Key) -> keyboard::Key {
     }
 }
 
+/// Converts a `PhysicalKey` from [`winit`] to an [`iced`] physical key.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced`]: https://github.com/iced-rs/iced/tree/0.12
+pub fn physical_key(
+    physical_key: winit::keyboard::PhysicalKey,
+) -> keyboard::key::Physical {
+    match physical_key {
+        winit::keyboard::PhysicalKey::Code(code) => key_code(code)
+            .map(keyboard::key::Physical::Code)
+            .unwrap_or(keyboard::key::Physical::Unidentified(
+                keyboard::key::NativeCode::Unidentified,
+            )),
+        winit::keyboard::PhysicalKey::Unidentified(code) => {
+            keyboard::key::Physical::Unidentified(native_key_code(code))
+        }
+    }
+}
+
+/// Converts a `KeyCode` from [`winit`] to an [`iced`] key code.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced`]: https://github.com/iced-rs/iced/tree/0.12
+pub fn key_code(
+    key_code: winit::keyboard::KeyCode,
+) -> Option<keyboard::key::Code> {
+    use winit::keyboard::KeyCode;
+
+    Some(match key_code {
+        KeyCode::Backquote => keyboard::key::Code::Backquote,
+        KeyCode::Backslash => keyboard::key::Code::Backslash,
+        KeyCode::BracketLeft => keyboard::key::Code::BracketLeft,
+        KeyCode::BracketRight => keyboard::key::Code::BracketRight,
+        KeyCode::Comma => keyboard::key::Code::Comma,
+        KeyCode::Digit0 => keyboard::key::Code::Digit0,
+        KeyCode::Digit1 => keyboard::key::Code::Digit1,
+        KeyCode::Digit2 => keyboard::key::Code::Digit2,
+        KeyCode::Digit3 => keyboard::key::Code::Digit3,
+        KeyCode::Digit4 => keyboard::key::Code::Digit4,
+        KeyCode::Digit5 => keyboard::key::Code::Digit5,
+        KeyCode::Digit6 => keyboard::key::Code::Digit6,
+        KeyCode::Digit7 => keyboard::key::Code::Digit7,
+        KeyCode::Digit8 => keyboard::key::Code::Digit8,
+        KeyCode::Digit9 => keyboard::key::Code::Digit9,
+        KeyCode::Equal => keyboard::key::Code::Equal,
+        KeyCode::IntlBackslash => keyboard::key::Code::IntlBackslash,
+        KeyCode::IntlRo => keyboard::key::Code::IntlRo,
+        KeyCode::IntlYen => keyboard::key::Code::IntlYen,
+        KeyCode::KeyA => keyboard::key::Code::KeyA,
+        KeyCode::KeyB => keyboard::key::Code::KeyB,
+        KeyCode::KeyC => keyboard::key::Code::KeyC,
+        KeyCode::KeyD => keyboard::key::Code::KeyD,
+        KeyCode::KeyE => keyboard::key::Code::KeyE,
+        KeyCode::KeyF => keyboard::key::Code::KeyF,
+        KeyCode::KeyG => keyboard::key::Code::KeyG,
+        KeyCode::KeyH => keyboard::key::Code::KeyH,
+        KeyCode::KeyI => keyboard::key::Code::KeyI,
+        KeyCode::KeyJ => keyboard::key::Code::KeyJ,
+        KeyCode::KeyK => keyboard::key::Code::KeyK,
+        KeyCode::KeyL => keyboard::key::Code::KeyL,
+        KeyCode::KeyM => keyboard::key::Code::KeyM,
+        KeyCode::KeyN => keyboard::key::Code::KeyN,
+        KeyCode::KeyO => keyboard::key::Code::KeyO,
+        KeyCode::KeyP => keyboard::key::Code::KeyP,
+        KeyCode::KeyQ => keyboard::key::Code::KeyQ,
+        KeyCode::KeyR => keyboard::key::Code::KeyR,
+        KeyCode::KeyS => keyboard::key::Code::KeyS,
+        KeyCode::KeyT => keyboard::key::Code::KeyT,
+        KeyCode::KeyU => keyboard::key::Code::KeyU,
+        KeyCode::KeyV => keyboard::key::Code::KeyV,
+        KeyCode::KeyW => keyboard::key::Code::KeyW,
+        KeyCode::KeyX => keyboard::key::Code::KeyX,
+        KeyCode::KeyY => keyboard::key::Code::KeyY,
+        KeyCode::KeyZ => keyboard::key::Code::KeyZ,
+        KeyCode::Minus => keyboard::key::Code::Minus,
+        KeyCode::Period => keyboard::key::Code::Period,
+        KeyCode::Quote => keyboard::key::Code::Quote,
+        KeyCode::Semicolon => keyboard::key::Code::Semicolon,
+        KeyCode::Slash => keyboard::key::Code::Slash,
+        KeyCode::AltLeft => keyboard::key::Code::AltLeft,
+        KeyCode::AltRight => keyboard::key::Code::AltRight,
+        KeyCode::Backspace => keyboard::key::Code::Backspace,
+        KeyCode::CapsLock => keyboard::key::Code::CapsLock,
+        KeyCode::ContextMenu => keyboard::key::Code::ContextMenu,
+        KeyCode::ControlLeft => keyboard::key::Code::ControlLeft,
+        KeyCode::ControlRight => keyboard::key::Code::ControlRight,
+        KeyCode::Enter => keyboard::key::Code::Enter,
+        KeyCode::SuperLeft => keyboard::key::Code::SuperLeft,
+        KeyCode::SuperRight => keyboard::key::Code::SuperRight,
+        KeyCode::ShiftLeft => keyboard::key::Code::ShiftLeft,
+        KeyCode::ShiftRight => keyboard::key::Code::ShiftRight,
+        KeyCode::Space => keyboard::key::Code::Space,
+        KeyCode::Tab => keyboard::key::Code::Tab,
+        KeyCode::Convert => keyboard::key::Code::Convert,
+        KeyCode::KanaMode => keyboard::key::Code::KanaMode,
+        KeyCode::Lang1 => keyboard::key::Code::Lang1,
+        KeyCode::Lang2 => keyboard::key::Code::Lang2,
+        KeyCode::Lang3 => keyboard::key::Code::Lang3,
+        KeyCode::Lang4 => keyboard::key::Code::Lang4,
+        KeyCode::Lang5 => keyboard::key::Code::Lang5,
+        KeyCode::NonConvert => keyboard::key::Code::NonConvert,
+        KeyCode::Delete => keyboard::key::Code::Delete,
+        KeyCode::End => keyboard::key::Code::End,
+        KeyCode::Help => keyboard::key::Code::Help,
+        KeyCode::Home => keyboard::key::Code::Home,
+        KeyCode::Insert => keyboard::key::Code::Insert,
+        KeyCode::PageDown => keyboard::key::Code::PageDown,
+        KeyCode::PageUp => keyboard::key::Code::PageUp,
+        KeyCode::ArrowDown => keyboard::key::Code::ArrowDown,
+        KeyCode::ArrowLeft => keyboard::key::Code::ArrowLeft,
+        KeyCode::ArrowRight => keyboard::key::Code::ArrowRight,
+        KeyCode::ArrowUp => keyboard::key::Code::ArrowUp,
+        KeyCode::NumLock => keyboard::key::Code::NumLock,
+        KeyCode::Numpad0 => keyboard::key::Code::Numpad0,
+        KeyCode::Numpad1 => keyboard::key::Code::Numpad1,
+        KeyCode::Numpad2 => keyboard::key::Code::Numpad2,
+        KeyCode::Numpad3 => keyboard::key::Code::Numpad3,
+        KeyCode::Numpad4 => keyboard::key::Code::Numpad4,
+        KeyCode::Numpad5 => keyboard::key::Code::Numpad5,
+        KeyCode::Numpad6 => keyboard::key::Code::Numpad6,
+        KeyCode::Numpad7 => keyboard::key::Code::Numpad7,
+        KeyCode::Numpad8 => keyboard::key::Code::Numpad8,
+        KeyCode::Numpad9 => keyboard::key::Code::Numpad9,
+        KeyCode::NumpadAdd => keyboard::key::Code::NumpadAdd,
+        KeyCode::NumpadBackspace => keyboard::key::Code::NumpadBackspace,
+        KeyCode::NumpadClear => keyboard::key::Code::NumpadClear,
+        KeyCode::NumpadClearEntry => keyboard::key::Code::NumpadClearEntry,
+        KeyCode::NumpadComma => keyboard::key::Code::NumpadComma,
+        KeyCode::NumpadDecimal => keyboard::key::Code::NumpadDecimal,
+        KeyCode::NumpadDivide => keyboard::key::Code::NumpadDivide,
+        KeyCode::NumpadEnter => keyboard::key::Code::NumpadEnter,
+        KeyCode::NumpadEqual => keyboard::key::Code::NumpadEqual,
+        KeyCode::NumpadHash => keyboard::key::Code::NumpadHash,
+        KeyCode::NumpadMemoryAdd => keyboard::key::Code::NumpadMemoryAdd,
+        KeyCode::NumpadMemoryClear => keyboard::key::Code::NumpadMemoryClear,
+        KeyCode::NumpadMemoryRecall => keyboard::key::Code::NumpadMemoryRecall,
+        KeyCode::NumpadMemoryStore => keyboard::key::Code::NumpadMemoryStore,
+        KeyCode::NumpadMemorySubtract => {
+            keyboard::key::Code::NumpadMemorySubtract
+        }
+        KeyCode::NumpadMultiply => keyboard::key::Code::NumpadMultiply,
+        KeyCode::NumpadParenLeft => keyboard::key::Code::NumpadParenLeft,
+        KeyCode::NumpadParenRight => keyboard::key::Code::NumpadParenRight,
+        KeyCode::NumpadStar => keyboard::key::Code::NumpadStar,
+        KeyCode::NumpadSubtract => keyboard::key::Code::NumpadSubtract,
+        KeyCode::Escape => keyboard::key::Code::Escape,
+        KeyCode::Fn => keyboard::key::Code::Fn,
+        KeyCode::FnLock => keyboard::key::Code::FnLock,
+        KeyCode::PrintScreen => keyboard::key::Code::PrintScreen,
+        KeyCode::ScrollLock => keyboard::key::Code::ScrollLock,
+        KeyCode::Pause => keyboard::key::Code::Pause,
+        KeyCode::BrowserBack => keyboard::key::Code::BrowserBack,
+        KeyCode::BrowserFavorites => keyboard::key::Code::BrowserFavorites,
+        KeyCode::BrowserForward => keyboard::key::Code::BrowserForward,
+        KeyCode::BrowserHome => keyboard::key::Code::BrowserHome,
+        KeyCode::BrowserRefresh => keyboard::key::Code::BrowserRefresh,
+        KeyCode::BrowserSearch => keyboard::key::Code::BrowserSearch,
+        KeyCode::BrowserStop => keyboard::key::Code::BrowserStop,
+        KeyCode::Eject => keyboard::key::Code::Eject,
+        KeyCode::LaunchApp1 => keyboard::key::Code::LaunchApp1,
+        KeyCode::LaunchApp2 => keyboard::key::Code::LaunchApp2,
+        KeyCode::LaunchMail => keyboard::key::Code::LaunchMail,
+        KeyCode::MediaPlayPause => keyboard::key::Code::MediaPlayPause,
+        KeyCode::MediaSelect => keyboard::key::Code::MediaSelect,
+        KeyCode::MediaStop => keyboard::key::Code::MediaStop,
+        KeyCode::MediaTrackNext => keyboard::key::Code::MediaTrackNext,
+        KeyCode::MediaTrackPrevious => keyboard::key::Code::MediaTrackPrevious,
+        KeyCode::Power => keyboard::key::Code::Power,
+        KeyCode::Sleep => keyboard::key::Code::Sleep,
+        KeyCode::AudioVolumeDown => keyboard::key::Code::AudioVolumeDown,
+        KeyCode::AudioVolumeMute => keyboard::key::Code::AudioVolumeMute,
+        KeyCode::AudioVolumeUp => keyboard::key::Code::AudioVolumeUp,
+        KeyCode::WakeUp => keyboard::key::Code::WakeUp,
+        KeyCode::Meta => keyboard::key::Code::Meta,
+        KeyCode::Hyper => keyboard::key::Code::Hyper,
+        KeyCode::Turbo => keyboard::key::Code::Turbo,
+        KeyCode::Abort => keyboard::key::Code::Abort,
+        KeyCode::Resume => keyboard::key::Code::Resume,
+        KeyCode::Suspend => keyboard::key::Code::Suspend,
+        KeyCode::Again => keyboard::key::Code::Again,
+        KeyCode::Copy => keyboard::key::Code::Copy,
+        KeyCode::Cut => keyboard::key::Code::Cut,
+        KeyCode::Find => keyboard::key::Code::Find,
+        KeyCode::Open => keyboard::key::Code::Open,
+        KeyCode::Paste => keyboard::key::Code::Paste,
+        KeyCode::Props => keyboard::key::Code::Props,
+        KeyCode::Select => keyboard::key::Code::Select,
+        KeyCode::Undo => keyboard::key::Code::Undo,
+        KeyCode::Hiragana => keyboard::key::Code::Hiragana,
+        KeyCode::Katakana => keyboard::key::Code::Katakana,
+        KeyCode::F1 => keyboard::key::Code::F1,
+        KeyCode::F2 => keyboard::key::Code::F2,
+        KeyCode::F3 => keyboard::key::Code::F3,
+        KeyCode::F4 => keyboard::key::Code::F4,
+        KeyCode::F5 => keyboard::key::Code::F5,
+        KeyCode::F6 => keyboard::key::Code::F6,
+        KeyCode::F7 => keyboard::key::Code::F7,
+        KeyCode::F8 => keyboard::key::Code::F8,
+        KeyCode::F9 => keyboard::key::Code::F9,
+        KeyCode::F10 => keyboard::key::Code::F10,
+        KeyCode::F11 => keyboard::key::Code::F11,
+        KeyCode::F12 => keyboard::key::Code::F12,
+        KeyCode::F13 => keyboard::key::Code::F13,
+        KeyCode::F14 => keyboard::key::Code::F14,
+        KeyCode::F15 => keyboard::key::Code::F15,
+        KeyCode::F16 => keyboard::key::Code::F16,
+        KeyCode::F17 => keyboard::key::Code::F17,
+        KeyCode::F18 => keyboard::key::Code::F18,
+        KeyCode::F19 => keyboard::key::Code::F19,
+        KeyCode::F20 => keyboard::key::Code::F20,
+        KeyCode::F21 => keyboard::key::Code::F21,
+        KeyCode::F22 => keyboard::key::Code::F22,
+        KeyCode::F23 => keyboard::key::Code::F23,
+        KeyCode::F24 => keyboard::key::Code::F24,
+        KeyCode::F25 => keyboard::key::Code::F25,
+        KeyCode::F26 => keyboard::key::Code::F26,
+        KeyCode::F27 => keyboard::key::Code::F27,
+        KeyCode::F28 => keyboard::key::Code::F28,
+        KeyCode::F29 => keyboard::key::Code::F29,
+        KeyCode::F30 => keyboard::key::Code::F30,
+        KeyCode::F31 => keyboard::key::Code::F31,
+        KeyCode::F32 => keyboard::key::Code::F32,
+        KeyCode::F33 => keyboard::key::Code::F33,
+        KeyCode::F34 => keyboard::key::Code::F34,
+        KeyCode::F35 => keyboard::key::Code::F35,
+        _ => None?,
+    })
+}
+
+/// Converts a `NativeKeyCode` from [`winit`] to an [`iced`] native key code.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced`]: https://github.com/iced-rs/iced/tree/0.12
+pub fn native_key_code(
+    native_key_code: winit::keyboard::NativeKeyCode,
+) -> keyboard::key::NativeCode {
+    use winit::keyboard::NativeKeyCode;
+
+    match native_key_code {
+        NativeKeyCode::Unidentified => keyboard::key::NativeCode::Unidentified,
+        NativeKeyCode::Android(code) => {
+            keyboard::key::NativeCode::Android(code)
+        }
+        NativeKeyCode::MacOS(code) => keyboard::key::NativeCode::MacOS(code),
+        NativeKeyCode::Windows(code) => {
+            keyboard::key::NativeCode::Windows(code)
+        }
+        NativeKeyCode::Xkb(code) => keyboard::key::NativeCode::Xkb(code),
+    }
+}
+
 /// Converts some [`UserAttention`] into it's `winit` counterpart.
 ///
 /// [`UserAttention`]: window::UserAttention


Test patch: