Rename platform to platform_impl

src/platform_impl/windows/dpi.rs

@@ -0,0 +1,189 @@
+#![allow(non_snake_case, unused_unsafe)]
+
+use std::mem;
+use std::os::raw::c_void;
+use std::sync::{Once, ONCE_INIT};
+
+use winapi::shared::minwindef::{BOOL, UINT, FALSE};
+use winapi::shared::windef::{
+    DPI_AWARENESS_CONTEXT,
+    DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE,
+    HMONITOR,
+    HWND,
+};
+use winapi::shared::winerror::S_OK;
+use winapi::um::libloaderapi::{GetProcAddress, LoadLibraryA};
+use winapi::um::shellscalingapi::{
+    MDT_EFFECTIVE_DPI,
+    MONITOR_DPI_TYPE,
+    PROCESS_DPI_AWARENESS,
+    PROCESS_PER_MONITOR_DPI_AWARE,
+};
+use winapi::um::wingdi::{GetDeviceCaps, LOGPIXELSX};
+use winapi::um::winnt::{HRESULT, LPCSTR};
+use winapi::um::winuser::{self, MONITOR_DEFAULTTONEAREST};
+
+const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2: DPI_AWARENESS_CONTEXT = -4isize as _;
+
+type SetProcessDPIAware = unsafe extern "system" fn () -> BOOL;
+type SetProcessDpiAwareness = unsafe extern "system" fn (
+    value: PROCESS_DPI_AWARENESS,
+) -> HRESULT;
+type SetProcessDpiAwarenessContext = unsafe extern "system" fn (
+    value: DPI_AWARENESS_CONTEXT,
+) -> BOOL;
+type GetDpiForWindow = unsafe extern "system" fn (hwnd: HWND) -> UINT;
+type GetDpiForMonitor = unsafe extern "system" fn (
+    hmonitor: HMONITOR,
+    dpi_type: MONITOR_DPI_TYPE,
+    dpi_x: *mut UINT,
+    dpi_y: *mut UINT,
+) -> HRESULT;
+type EnableNonClientDpiScaling = unsafe extern "system" fn (hwnd: HWND) -> BOOL;
+
+// Helper function to dynamically load function pointer.
+// `library` and `function` must be zero-terminated.
+fn get_function_impl(library: &str, function: &str) -> Option<*const c_void> {
+    assert_eq!(library.chars().last(), Some('\0'));
+    assert_eq!(function.chars().last(), Some('\0'));
+
+    // Library names we will use are ASCII so we can use the A version to avoid string conversion.
+    let module = unsafe { LoadLibraryA(library.as_ptr() as LPCSTR) };
+    if module.is_null() {
+        return None;
+    }
+
+    let function_ptr = unsafe { GetProcAddress(module, function.as_ptr() as LPCSTR) };
+    if function_ptr.is_null() {
+        return None;
+    }
+
+    Some(function_ptr as _)
+}
+
+macro_rules! get_function {
+    ($lib:expr, $func:ident) => {
+        get_function_impl(concat!($lib, '\0'), concat!(stringify!($func), '\0'))
+            .map(|f| unsafe { mem::transmute::<*const _, $func>(f) })
+    }
+}
+
+lazy_static! {
+    static ref GET_DPI_FOR_WINDOW: Option<GetDpiForWindow> = get_function!(
+        "user32.dll",
+        GetDpiForWindow
+    );
+    static ref GET_DPI_FOR_MONITOR: Option<GetDpiForMonitor> = get_function!(
+        "shcore.dll",
+        GetDpiForMonitor
+    );
+    static ref ENABLE_NON_CLIENT_DPI_SCALING: Option<EnableNonClientDpiScaling> = get_function!(
+        "user32.dll",
+        EnableNonClientDpiScaling
+    );
+}
+
+pub fn become_dpi_aware(enable: bool) {
+    if !enable { return; }
+    static ENABLE_DPI_AWARENESS: Once = ONCE_INIT;
+    ENABLE_DPI_AWARENESS.call_once(|| { unsafe {
+        if let Some(SetProcessDpiAwarenessContext) = get_function!(
+            "user32.dll",
+            SetProcessDpiAwarenessContext
+        ) {
+            // We are on Windows 10 Anniversary Update (1607) or later.
+            if SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)
+            == FALSE {
+                // V2 only works with Windows 10 Creators Update (1703). Try using the older
+                // V1 if we can't set V2.
+                SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE);
+            }
+        } else if let Some(SetProcessDpiAwareness) = get_function!(
+            "shcore.dll",
+            SetProcessDpiAwareness
+        ) {
+            // We are on Windows 8.1 or later.
+            SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
+        } else if let Some(SetProcessDPIAware) = get_function!(
+            "user32.dll",
+            SetProcessDPIAware
+        ) {
+            // We are on Vista or later.
+            SetProcessDPIAware();
+        }
+    } });
+}
+
+pub fn enable_non_client_dpi_scaling(hwnd: HWND) {
+    unsafe {
+        if let Some(EnableNonClientDpiScaling) = *ENABLE_NON_CLIENT_DPI_SCALING {
+            EnableNonClientDpiScaling(hwnd);
+        }
+    }
+}
+
+pub fn get_monitor_dpi(hmonitor: HMONITOR) -> Option<u32> {
+    unsafe {
+        if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
+            // We are on Windows 8.1 or later.
+            let mut dpi_x = 0;
+            let mut dpi_y = 0;
+            if GetDpiForMonitor(hmonitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
+                // MSDN says that "the values of *dpiX and *dpiY are identical. You only need to
+                // record one of the values to determine the DPI and respond appropriately".
+                // https://msdn.microsoft.com/en-us/library/windows/desktop/dn280510(v=vs.85).aspx
+                return Some(dpi_x as u32)
+            }
+        }
+    }
+    None
+}
+
+pub const BASE_DPI: u32 = 96;
+pub fn dpi_to_scale_factor(dpi: u32) -> f64 {
+    dpi as f64 / BASE_DPI as f64
+}
+
+pub unsafe fn get_hwnd_dpi(hwnd: HWND) -> u32 {
+    let hdc = winuser::GetDC(hwnd);
+    if hdc.is_null() {
+        panic!("[winit] `GetDC` returned null!");
+    }
+    if let Some(GetDpiForWindow) = *GET_DPI_FOR_WINDOW {
+        // We are on Windows 10 Anniversary Update (1607) or later.
+        match GetDpiForWindow(hwnd) {
+            0 => BASE_DPI, // 0 is returned if hwnd is invalid
+            dpi => dpi as u32,
+        }
+    } else if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
+        // We are on Windows 8.1 or later.
+        let monitor = winuser::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
+        if monitor.is_null() {
+            return BASE_DPI;
+        }
+
+        let mut dpi_x = 0;
+        let mut dpi_y = 0;
+        if GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == S_OK {
+            dpi_x as u32
+        } else {
+            BASE_DPI
+        }
+    } else {
+        // We are on Vista or later.
+        if winuser::IsProcessDPIAware() != FALSE {
+            // If the process is DPI aware, then scaling must be handled by the application using
+            // this DPI value.
+            GetDeviceCaps(hdc, LOGPIXELSX) as u32
+        } else {
+            // If the process is DPI unaware, then scaling is performed by the OS; we thus return
+            // 96 (scale factor 1.0) to prevent the window from being re-scaled by both the
+            // application and the WM.
+            BASE_DPI
+        }
+    }
+}
+
+pub fn get_hwnd_scale_factor(hwnd: HWND) -> f64 {
+    dpi_to_scale_factor(unsafe { get_hwnd_dpi(hwnd) })
+}

src/platform_impl/windows/drop_handler.rs

@@ -0,0 +1,211 @@
+use std::ffi::OsString;
+use std::os::windows::ffi::OsStringExt;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{mem, ptr};
+use crossbeam_channel::Sender;
+
+use winapi::ctypes::c_void;
+use winapi::shared::guiddef::REFIID;
+use winapi::shared::minwindef::{DWORD, MAX_PATH, UINT, ULONG};
+use winapi::shared::windef::{HWND, POINTL};
+use winapi::shared::winerror::S_OK;
+use winapi::um::objidl::IDataObject;
+use winapi::um::oleidl::{IDropTarget, IDropTargetVtbl};
+use winapi::um::winnt::HRESULT;
+use winapi::um::{shellapi, unknwnbase};
+
+use platform_impl::platform::WindowId;
+
+use {Event, WindowId as SuperWindowId};
+
+#[repr(C)]
+pub struct FileDropHandlerData {
+    pub interface: IDropTarget,
+    refcount: AtomicUsize,
+    window: HWND,
+    // event_sender: Sender<Event<()>>
+}
+
+pub struct FileDropHandler {
+    pub data: *mut FileDropHandlerData,
+}
+
+#[allow(non_snake_case)]
+impl FileDropHandler {
+    pub fn new(window: HWND/*, event_sender: Sender<Event<()>>*/) -> FileDropHandler {
+        let data = Box::new(FileDropHandlerData {
+            interface: IDropTarget {
+                lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl,
+            },
+            refcount: AtomicUsize::new(1),
+            window,
+            // event_sender,
+        });
+        FileDropHandler {
+            data: Box::into_raw(data),
+        }
+    }
+
+    // Implement IUnknown
+    pub unsafe extern "system" fn QueryInterface(
+        _this: *mut unknwnbase::IUnknown,
+        _riid: REFIID,
+        _ppvObject: *mut *mut c_void,
+    ) -> HRESULT {
+        // This function doesn't appear to be required for an `IDropTarget`.
+        // An implementation would be nice however.
+        unimplemented!();
+    }
+
+    pub unsafe extern "system" fn AddRef(this: *mut unknwnbase::IUnknown) -> ULONG {
+        let drop_handler_data = Self::from_interface(this);
+        let count = drop_handler_data.refcount.fetch_add(1, Ordering::Release) + 1;
+        count as ULONG
+    }
+
+    pub unsafe extern "system" fn Release(this: *mut unknwnbase::IUnknown) -> ULONG {
+        let drop_handler = Self::from_interface(this);
+        let count = drop_handler.refcount.fetch_sub(1, Ordering::Release) - 1;
+        if count == 0 {
+            // Destroy the underlying data
+            Box::from_raw(drop_handler as *mut FileDropHandlerData);
+        }
+        count as ULONG
+    }
+
+    pub unsafe extern "system" fn DragEnter(
+        this: *mut IDropTarget,
+        pDataObj: *const IDataObject,
+        _grfKeyState: DWORD,
+        _pt: *const POINTL,
+        _pdwEffect: *mut DWORD,
+    ) -> HRESULT {
+        use events::WindowEvent::HoveredFile;
+        let drop_handler = Self::from_interface(this);
+        Self::iterate_filenames(pDataObj, |filename| {
+            drop_handler.send_event(Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(drop_handler.window)),
+                event: HoveredFile(filename),
+            });
+        });
+
+        S_OK
+    }
+
+    pub unsafe extern "system" fn DragOver(
+        _this: *mut IDropTarget,
+        _grfKeyState: DWORD,
+        _pt: *const POINTL,
+        _pdwEffect: *mut DWORD,
+    ) -> HRESULT {
+        S_OK
+    }
+
+    pub unsafe extern "system" fn DragLeave(this: *mut IDropTarget) -> HRESULT {
+        use events::WindowEvent::HoveredFileCancelled;
+        let drop_handler = Self::from_interface(this);
+        drop_handler.send_event(Event::WindowEvent {
+            window_id: SuperWindowId(WindowId(drop_handler.window)),
+            event: HoveredFileCancelled,
+        });
+
+        S_OK
+    }
+
+    pub unsafe extern "system" fn Drop(
+        this: *mut IDropTarget,
+        pDataObj: *const IDataObject,
+        _grfKeyState: DWORD,
+        _pt: *const POINTL,
+        _pdwEffect: *mut DWORD,
+    ) -> HRESULT {
+        use events::WindowEvent::DroppedFile;
+        let drop_handler = Self::from_interface(this);
+        let hdrop = Self::iterate_filenames(pDataObj, |filename| {
+            drop_handler.send_event(Event::WindowEvent {
+                window_id: SuperWindowId(WindowId(drop_handler.window)),
+                event: DroppedFile(filename),
+            });
+        });
+        shellapi::DragFinish(hdrop);
+
+        S_OK
+    }
+
+    unsafe fn from_interface<'a, InterfaceT>(this: *mut InterfaceT) -> &'a mut FileDropHandlerData {
+        &mut *(this as *mut _)
+    }
+
+    unsafe fn iterate_filenames<F>(data_obj: *const IDataObject, callback: F) -> shellapi::HDROP
+    where
+        F: Fn(PathBuf),
+    {
+        use winapi::ctypes::wchar_t;
+        use winapi::shared::winerror::SUCCEEDED;
+        use winapi::shared::wtypes::{CLIPFORMAT, DVASPECT_CONTENT};
+        use winapi::um::objidl::{FORMATETC, TYMED_HGLOBAL};
+        use winapi::um::shellapi::DragQueryFileW;
+        use winapi::um::winuser::CF_HDROP;
+
+        let mut drop_format = FORMATETC {
+            cfFormat: CF_HDROP as CLIPFORMAT,
+            ptd: ptr::null(),
+            dwAspect: DVASPECT_CONTENT,
+            lindex: -1,
+            tymed: TYMED_HGLOBAL,
+        };
+
+        let mut medium = mem::uninitialized();
+        if SUCCEEDED((*data_obj).GetData(&mut drop_format, &mut medium)) {
+            let hglobal = (*medium.u).hGlobal();
+            let hdrop = (*hglobal) as shellapi::HDROP;
+
+            // The second parameter (0xFFFFFFFF) instructs the function to return the item count
+            let item_count = DragQueryFileW(hdrop, 0xFFFFFFFF, ptr::null_mut(), 0);
+
+            let mut pathbuf: [wchar_t; MAX_PATH] = mem::uninitialized();
+
+            for i in 0..item_count {
+                let character_count =
+                    DragQueryFileW(hdrop, i, pathbuf.as_mut_ptr(), MAX_PATH as UINT) as usize;
+
+                if character_count > 0 {
+                    callback(OsString::from_wide(&pathbuf[0..character_count]).into());
+                }
+            }
+
+            return hdrop;
+        }
+
+        // The call to `GetData` must succeed and the file handle must be returned before this
+        // point
+        unreachable!();
+    }
+}
+
+impl FileDropHandlerData {
+    fn send_event(&self, event: Event<()>) {
+        // self.event_sender.send(event).ok();
+    }
+}
+
+impl Drop for FileDropHandler {
+    fn drop(&mut self) {
+        unsafe {
+            FileDropHandler::Release(self.data as *mut unknwnbase::IUnknown);
+        }
+    }
+}
+
+static DROP_TARGET_VTBL: IDropTargetVtbl = IDropTargetVtbl {
+    parent: unknwnbase::IUnknownVtbl {
+        QueryInterface: FileDropHandler::QueryInterface,
+        AddRef: FileDropHandler::AddRef,
+        Release: FileDropHandler::Release,
+    },
+    DragEnter: FileDropHandler::DragEnter,
+    DragOver: FileDropHandler::DragOver,
+    DragLeave: FileDropHandler::DragLeave,
+    Drop: FileDropHandler::Drop,
+};

src/platform_impl/windows/event.rs

@@ -0,0 +1,267 @@
+use std::char;
+use std::os::raw::c_int;
+
+use events::VirtualKeyCode;
+use events::ModifiersState;
+
+use winapi::shared::minwindef::{WPARAM, LPARAM, UINT};
+use winapi::um::winuser;
+
+use ScanCode;
+
+pub fn get_key_mods() -> ModifiersState {
+    let mut mods = ModifiersState::default();
+    unsafe {
+        if winuser::GetKeyState(winuser::VK_SHIFT) & (1 << 15) == (1 << 15) {
+            mods.shift = true;
+        }
+        if winuser::GetKeyState(winuser::VK_CONTROL) & (1 << 15) == (1 << 15) {
+            mods.ctrl = true;
+        }
+        if winuser::GetKeyState(winuser::VK_MENU) & (1 << 15) == (1 << 15) {
+            mods.alt = true;
+        }
+        if (winuser::GetKeyState(winuser::VK_LWIN) | winuser::GetKeyState(winuser::VK_RWIN)) & (1 << 15) == (1 << 15) {
+            mods.logo = true;
+        }
+    }
+    mods
+}
+
+pub fn vkey_to_winit_vkey(vkey: c_int) -> Option<VirtualKeyCode> {
+    // VK_* codes are documented here https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+    match vkey {
+        //winuser::VK_LBUTTON => Some(VirtualKeyCode::Lbutton),
+        //winuser::VK_RBUTTON => Some(VirtualKeyCode::Rbutton),
+        //winuser::VK_CANCEL => Some(VirtualKeyCode::Cancel),
+        //winuser::VK_MBUTTON => Some(VirtualKeyCode::Mbutton),
+        //winuser::VK_XBUTTON1 => Some(VirtualKeyCode::Xbutton1),
+        //winuser::VK_XBUTTON2 => Some(VirtualKeyCode::Xbutton2),
+        winuser::VK_BACK => Some(VirtualKeyCode::Back),
+        winuser::VK_TAB => Some(VirtualKeyCode::Tab),
+        //winuser::VK_CLEAR => Some(VirtualKeyCode::Clear),
+        winuser::VK_RETURN => Some(VirtualKeyCode::Return),
+        winuser::VK_LSHIFT => Some(VirtualKeyCode::LShift),
+        winuser::VK_RSHIFT => Some(VirtualKeyCode::RShift),
+        winuser::VK_LCONTROL => Some(VirtualKeyCode::LControl),
+        winuser::VK_RCONTROL => Some(VirtualKeyCode::RControl),
+        winuser::VK_LMENU => Some(VirtualKeyCode::LAlt),
+        winuser::VK_RMENU => Some(VirtualKeyCode::RAlt),
+        winuser::VK_PAUSE => Some(VirtualKeyCode::Pause),
+        winuser::VK_CAPITAL => Some(VirtualKeyCode::Capital),
+        winuser::VK_KANA => Some(VirtualKeyCode::Kana),
+        //winuser::VK_HANGUEL => Some(VirtualKeyCode::Hanguel),
+        //winuser::VK_HANGUL => Some(VirtualKeyCode::Hangul),
+        //winuser::VK_JUNJA => Some(VirtualKeyCode::Junja),
+        //winuser::VK_FINAL => Some(VirtualKeyCode::Final),
+        //winuser::VK_HANJA => Some(VirtualKeyCode::Hanja),
+        winuser::VK_KANJI => Some(VirtualKeyCode::Kanji),
+        winuser::VK_ESCAPE => Some(VirtualKeyCode::Escape),
+        winuser::VK_CONVERT => Some(VirtualKeyCode::Convert),
+        winuser::VK_NONCONVERT => Some(VirtualKeyCode::NoConvert),
+        //winuser::VK_ACCEPT => Some(VirtualKeyCode::Accept),
+        //winuser::VK_MODECHANGE => Some(VirtualKeyCode::Modechange),
+        winuser::VK_SPACE => Some(VirtualKeyCode::Space),
+        winuser::VK_PRIOR => Some(VirtualKeyCode::PageUp),
+        winuser::VK_NEXT => Some(VirtualKeyCode::PageDown),
+        winuser::VK_END => Some(VirtualKeyCode::End),
+        winuser::VK_HOME => Some(VirtualKeyCode::Home),
+        winuser::VK_LEFT => Some(VirtualKeyCode::Left),
+        winuser::VK_UP => Some(VirtualKeyCode::Up),
+        winuser::VK_RIGHT => Some(VirtualKeyCode::Right),
+        winuser::VK_DOWN => Some(VirtualKeyCode::Down),
+        //winuser::VK_SELECT => Some(VirtualKeyCode::Select),
+        //winuser::VK_PRINT => Some(VirtualKeyCode::Print),
+        //winuser::VK_EXECUTE => Some(VirtualKeyCode::Execute),
+        winuser::VK_SNAPSHOT => Some(VirtualKeyCode::Snapshot),
+        winuser::VK_INSERT => Some(VirtualKeyCode::Insert),
+        winuser::VK_DELETE => Some(VirtualKeyCode::Delete),
+        //winuser::VK_HELP => Some(VirtualKeyCode::Help),
+        0x30 => Some(VirtualKeyCode::Key0),
+        0x31 => Some(VirtualKeyCode::Key1),
+        0x32 => Some(VirtualKeyCode::Key2),
+        0x33 => Some(VirtualKeyCode::Key3),
+        0x34 => Some(VirtualKeyCode::Key4),
+        0x35 => Some(VirtualKeyCode::Key5),
+        0x36 => Some(VirtualKeyCode::Key6),
+        0x37 => Some(VirtualKeyCode::Key7),
+        0x38 => Some(VirtualKeyCode::Key8),
+        0x39 => Some(VirtualKeyCode::Key9),
+        0x41 => Some(VirtualKeyCode::A),
+        0x42 => Some(VirtualKeyCode::B),
+        0x43 => Some(VirtualKeyCode::C),
+        0x44 => Some(VirtualKeyCode::D),
+        0x45 => Some(VirtualKeyCode::E),
+        0x46 => Some(VirtualKeyCode::F),
+        0x47 => Some(VirtualKeyCode::G),
+        0x48 => Some(VirtualKeyCode::H),
+        0x49 => Some(VirtualKeyCode::I),
+        0x4A => Some(VirtualKeyCode::J),
+        0x4B => Some(VirtualKeyCode::K),
+        0x4C => Some(VirtualKeyCode::L),
+        0x4D => Some(VirtualKeyCode::M),
+        0x4E => Some(VirtualKeyCode::N),
+        0x4F => Some(VirtualKeyCode::O),
+        0x50 => Some(VirtualKeyCode::P),
+        0x51 => Some(VirtualKeyCode::Q),
+        0x52 => Some(VirtualKeyCode::R),
+        0x53 => Some(VirtualKeyCode::S),
+        0x54 => Some(VirtualKeyCode::T),
+        0x55 => Some(VirtualKeyCode::U),
+        0x56 => Some(VirtualKeyCode::V),
+        0x57 => Some(VirtualKeyCode::W),
+        0x58 => Some(VirtualKeyCode::X),
+        0x59 => Some(VirtualKeyCode::Y),
+        0x5A => Some(VirtualKeyCode::Z),
+        //winuser::VK_LWIN => Some(VirtualKeyCode::Lwin),
+        //winuser::VK_RWIN => Some(VirtualKeyCode::Rwin),
+        winuser::VK_APPS => Some(VirtualKeyCode::Apps),
+        winuser::VK_SLEEP => Some(VirtualKeyCode::Sleep),
+        winuser::VK_NUMPAD0 => Some(VirtualKeyCode::Numpad0),
+        winuser::VK_NUMPAD1 => Some(VirtualKeyCode::Numpad1),
+        winuser::VK_NUMPAD2 => Some(VirtualKeyCode::Numpad2),
+        winuser::VK_NUMPAD3 => Some(VirtualKeyCode::Numpad3),
+        winuser::VK_NUMPAD4 => Some(VirtualKeyCode::Numpad4),
+        winuser::VK_NUMPAD5 => Some(VirtualKeyCode::Numpad5),
+        winuser::VK_NUMPAD6 => Some(VirtualKeyCode::Numpad6),
+        winuser::VK_NUMPAD7 => Some(VirtualKeyCode::Numpad7),
+        winuser::VK_NUMPAD8 => Some(VirtualKeyCode::Numpad8),
+        winuser::VK_NUMPAD9 => Some(VirtualKeyCode::Numpad9),
+        winuser::VK_MULTIPLY => Some(VirtualKeyCode::Multiply),
+        winuser::VK_ADD => Some(VirtualKeyCode::Add),
+        //winuser::VK_SEPARATOR => Some(VirtualKeyCode::Separator),
+        winuser::VK_SUBTRACT => Some(VirtualKeyCode::Subtract),
+        winuser::VK_DECIMAL => Some(VirtualKeyCode::Decimal),
+        winuser::VK_DIVIDE => Some(VirtualKeyCode::Divide),
+        winuser::VK_F1 => Some(VirtualKeyCode::F1),
+        winuser::VK_F2 => Some(VirtualKeyCode::F2),
+        winuser::VK_F3 => Some(VirtualKeyCode::F3),
+        winuser::VK_F4 => Some(VirtualKeyCode::F4),
+        winuser::VK_F5 => Some(VirtualKeyCode::F5),
+        winuser::VK_F6 => Some(VirtualKeyCode::F6),
+        winuser::VK_F7 => Some(VirtualKeyCode::F7),
+        winuser::VK_F8 => Some(VirtualKeyCode::F8),
+        winuser::VK_F9 => Some(VirtualKeyCode::F9),
+        winuser::VK_F10 => Some(VirtualKeyCode::F10),
+        winuser::VK_F11 => Some(VirtualKeyCode::F11),
+        winuser::VK_F12 => Some(VirtualKeyCode::F12),
+        winuser::VK_F13 => Some(VirtualKeyCode::F13),
+        winuser::VK_F14 => Some(VirtualKeyCode::F14),
+        winuser::VK_F15 => Some(VirtualKeyCode::F15),
+        winuser::VK_F16 => Some(VirtualKeyCode::F16),
+        winuser::VK_F17 => Some(VirtualKeyCode::F17),
+        winuser::VK_F18 => Some(VirtualKeyCode::F18),
+        winuser::VK_F19 => Some(VirtualKeyCode::F19),
+        winuser::VK_F20 => Some(VirtualKeyCode::F20),
+        winuser::VK_F21 => Some(VirtualKeyCode::F21),
+        winuser::VK_F22 => Some(VirtualKeyCode::F22),
+        winuser::VK_F23 => Some(VirtualKeyCode::F23),
+        winuser::VK_F24 => Some(VirtualKeyCode::F24),
+        winuser::VK_NUMLOCK => Some(VirtualKeyCode::Numlock),
+        winuser::VK_SCROLL => Some(VirtualKeyCode::Scroll),
+        winuser::VK_BROWSER_BACK => Some(VirtualKeyCode::NavigateBackward),
+        winuser::VK_BROWSER_FORWARD => Some(VirtualKeyCode::NavigateForward),
+        winuser::VK_BROWSER_REFRESH => Some(VirtualKeyCode::WebRefresh),
+        winuser::VK_BROWSER_STOP => Some(VirtualKeyCode::WebStop),
+        winuser::VK_BROWSER_SEARCH => Some(VirtualKeyCode::WebSearch),
+        winuser::VK_BROWSER_FAVORITES => Some(VirtualKeyCode::WebFavorites),
+        winuser::VK_BROWSER_HOME => Some(VirtualKeyCode::WebHome),
+        winuser::VK_VOLUME_MUTE => Some(VirtualKeyCode::Mute),
+        winuser::VK_VOLUME_DOWN => Some(VirtualKeyCode::VolumeDown),
+        winuser::VK_VOLUME_UP => Some(VirtualKeyCode::VolumeUp),
+        winuser::VK_MEDIA_NEXT_TRACK => Some(VirtualKeyCode::NextTrack),
+        winuser::VK_MEDIA_PREV_TRACK => Some(VirtualKeyCode::PrevTrack),
+        winuser::VK_MEDIA_STOP => Some(VirtualKeyCode::MediaStop),
+        winuser::VK_MEDIA_PLAY_PAUSE => Some(VirtualKeyCode::PlayPause),
+        winuser::VK_LAUNCH_MAIL => Some(VirtualKeyCode::Mail),
+        winuser::VK_LAUNCH_MEDIA_SELECT => Some(VirtualKeyCode::MediaSelect),
+        /*winuser::VK_LAUNCH_APP1 => Some(VirtualKeyCode::Launch_app1),
+        winuser::VK_LAUNCH_APP2 => Some(VirtualKeyCode::Launch_app2),*/
+        winuser::VK_OEM_PLUS => Some(VirtualKeyCode::Equals),
+        winuser::VK_OEM_COMMA => Some(VirtualKeyCode::Comma),
+        winuser::VK_OEM_MINUS => Some(VirtualKeyCode::Minus),
+        winuser::VK_OEM_PERIOD => Some(VirtualKeyCode::Period),
+        winuser::VK_OEM_1 => map_text_keys(vkey),
+        winuser::VK_OEM_2 => map_text_keys(vkey),
+        winuser::VK_OEM_3 => map_text_keys(vkey),
+        winuser::VK_OEM_4 => map_text_keys(vkey),
+        winuser::VK_OEM_5 => map_text_keys(vkey),
+        winuser::VK_OEM_6 => map_text_keys(vkey),
+        winuser::VK_OEM_7 => map_text_keys(vkey),
+        /*winuser::VK_OEM_8 => Some(VirtualKeyCode::Oem_8), */
+        winuser::VK_OEM_102 => Some(VirtualKeyCode::OEM102),
+        /*winuser::VK_PROCESSKEY => Some(VirtualKeyCode::Processkey),
+        winuser::VK_PACKET => Some(VirtualKeyCode::Packet),
+        winuser::VK_ATTN => Some(VirtualKeyCode::Attn),
+        winuser::VK_CRSEL => Some(VirtualKeyCode::Crsel),
+        winuser::VK_EXSEL => Some(VirtualKeyCode::Exsel),
+        winuser::VK_EREOF => Some(VirtualKeyCode::Ereof),
+        winuser::VK_PLAY => Some(VirtualKeyCode::Play),
+        winuser::VK_ZOOM => Some(VirtualKeyCode::Zoom),
+        winuser::VK_NONAME => Some(VirtualKeyCode::Noname),
+        winuser::VK_PA1 => Some(VirtualKeyCode::Pa1),
+        winuser::VK_OEM_CLEAR => Some(VirtualKeyCode::Oem_clear),*/
+        _ => None
+    }
+}
+
+pub fn handle_extended_keys(vkey: c_int, mut scancode: UINT, extended: bool) -> Option<(c_int, UINT)> {
+    // Welcome to hell https://blog.molecular-matters.com/2011/09/05/properly-handling-keyboard-input/
+    let vkey = match vkey {
+        winuser::VK_SHIFT => unsafe { winuser::MapVirtualKeyA(
+            scancode,
+            winuser::MAPVK_VSC_TO_VK_EX,
+        ) as _ },
+        winuser::VK_CONTROL => if extended {
+            winuser::VK_RCONTROL
+        } else {
+            winuser::VK_LCONTROL
+        },
+        winuser::VK_MENU => if extended {
+            winuser::VK_RMENU
+        } else {
+            winuser::VK_LMENU
+        },
+        _ => match scancode {
+            // This is only triggered when using raw input. Without this check, we get two events whenever VK_PAUSE is
+            // pressed, the first one having scancode 0x1D but vkey VK_PAUSE...
+            0x1D if vkey == winuser::VK_PAUSE => return None,
+            // ...and the second having scancode 0x45 but an unmatched vkey!
+            0x45 => winuser::VK_PAUSE,
+            // VK_PAUSE and VK_SCROLL have the same scancode when using modifiers, alongside incorrect vkey values.
+            0x46 => {
+                if extended {
+                    scancode = 0x45;
+                    winuser::VK_PAUSE
+                } else {
+                    winuser::VK_SCROLL
+                }
+            },
+            _ => vkey,
+        },
+    };
+    Some((vkey, scancode))
+}
+
+pub fn process_key_params(wparam: WPARAM, lparam: LPARAM) -> Option<(ScanCode, Option<VirtualKeyCode>)> {
+    let scancode = ((lparam >> 16) & 0xff) as UINT;
+    let extended = (lparam & 0x01000000) != 0;
+    handle_extended_keys(wparam as _, scancode, extended)
+        .map(|(vkey, scancode)| (scancode, vkey_to_winit_vkey(vkey)))
+}
+
+// This is needed as windows doesn't properly distinguish
+// some virtual key codes for different keyboard layouts
+fn map_text_keys(win_virtual_key: i32) -> Option<VirtualKeyCode> {
+    let char_key = unsafe { winuser::MapVirtualKeyA(win_virtual_key as u32, winuser::MAPVK_VK_TO_CHAR) } & 0x7FFF;
+    match char::from_u32(char_key) {
+        Some(';') => Some(VirtualKeyCode::Semicolon),
+        Some('/') => Some(VirtualKeyCode::Slash),
+        Some('`') => Some(VirtualKeyCode::Grave),
+        Some('[') => Some(VirtualKeyCode::LBracket),
+        Some(']') => Some(VirtualKeyCode::RBracket),
+        Some('\'') => Some(VirtualKeyCode::Apostrophe),
+        Some('\\') => Some(VirtualKeyCode::Backslash),
+        _ => None
+    }
+}

src/platform_impl/windows/icon.rs

@@ -0,0 +1,114 @@
+use std::{self, mem, ptr};
+use std::os::windows::ffi::OsStrExt;
+use std::path::Path;
+
+use winapi::ctypes::{c_int, wchar_t};
+use winapi::shared::minwindef::{BYTE, LPARAM, WPARAM};
+use winapi::shared::windef::{HICON, HWND};
+use winapi::um::winuser;
+
+use {Pixel, PIXEL_SIZE, Icon};
+use platform_impl::platform::util;
+
+impl Pixel {
+    fn to_bgra(&mut self) {
+        mem::swap(&mut self.r, &mut self.b);
+    }
+}
+
+#[derive(Debug)]
+pub enum IconType {
+    Small = winuser::ICON_SMALL as isize,
+    Big = winuser::ICON_BIG as isize,
+}
+
+#[derive(Clone, Debug)]
+pub struct WinIcon {
+    pub handle: HICON,
+}
+
+unsafe impl Send for WinIcon {}
+
+impl WinIcon {
+    #[allow(dead_code)]
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, util::WinError> {
+        let wide_path: Vec<u16> = path.as_ref().as_os_str().encode_wide().collect();
+        let handle = unsafe {
+            winuser::LoadImageW(
+                ptr::null_mut(),
+                wide_path.as_ptr() as *const wchar_t,
+                winuser::IMAGE_ICON,
+                0, // 0 indicates that we want to use the actual width
+                0, // and height
+                winuser::LR_LOADFROMFILE,
+            ) as HICON
+        };
+        if !handle.is_null() {
+            Ok(WinIcon { handle })
+        } else {
+            Err(util::WinError::from_last_error())
+        }
+    }
+
+    pub fn from_icon(icon: Icon) -> Result<Self, util::WinError> {
+        Self::from_rgba(icon.rgba, icon.width, icon.height)
+    }
+
+    pub fn from_rgba(mut rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, util::WinError> {
+        assert_eq!(rgba.len() % PIXEL_SIZE, 0);
+        let pixel_count = rgba.len() / PIXEL_SIZE;
+        assert_eq!(pixel_count, (width * height) as usize);
+        let mut and_mask = Vec::with_capacity(pixel_count);
+        let pixels = rgba.as_mut_ptr() as *mut Pixel; // how not to write idiomatic Rust
+        for pixel_index in 0..pixel_count {
+            let pixel = unsafe { &mut *pixels.offset(pixel_index as isize) };
+            and_mask.push(pixel.a.wrapping_sub(std::u8::MAX)); // invert alpha channel
+            pixel.to_bgra();
+        }
+        assert_eq!(and_mask.len(), pixel_count);
+        let handle = unsafe {
+            winuser::CreateIcon(
+                ptr::null_mut(),
+                width as c_int,
+                height as c_int,
+                1,
+                (PIXEL_SIZE * 8) as BYTE,
+                and_mask.as_ptr() as *const BYTE,
+                rgba.as_ptr() as *const BYTE,
+            ) as HICON
+        };
+        if !handle.is_null() {
+            Ok(WinIcon { handle })
+        } else {
+            Err(util::WinError::from_last_error())
+        }
+    }
+
+    pub fn set_for_window(&self, hwnd: HWND, icon_type: IconType) {
+        unsafe {
+            winuser::SendMessageW(
+                hwnd,
+                winuser::WM_SETICON,
+                icon_type as WPARAM,
+                self.handle as LPARAM,
+            );
+        }
+    }
+}
+
+impl Drop for WinIcon {
+    fn drop(&mut self) {
+        unsafe { winuser::DestroyIcon(self.handle) };
+    }
+}
+
+pub fn unset_for_window(hwnd: HWND, icon_type: IconType) {
+    unsafe {
+        winuser::SendMessageW(
+            hwnd,
+            winuser::WM_SETICON,
+            icon_type as WPARAM,
+            0 as LPARAM,
+        );
+    }
+}

src/platform_impl/windows/mod.rs

@@ -0,0 +1,59 @@
+#![cfg(target_os = "windows")]
+
+use winapi;
+use winapi::shared::windef::HWND;
+
+pub use self::events_loop::{EventLoop, EventLoopProxy};
+pub use self::monitor::MonitorId;
+pub use self::window::Window;
+
+#[derive(Clone, Default)]
+pub struct PlatformSpecificWindowBuilderAttributes {
+    pub parent: Option<HWND>,
+    pub taskbar_icon: Option<::Icon>,
+    pub no_redirection_bitmap: bool,
+}
+
+unsafe impl Send for PlatformSpecificWindowBuilderAttributes {}
+unsafe impl Sync for PlatformSpecificWindowBuilderAttributes {}
+
+// Cursor name in UTF-16. Used to set cursor in `WM_SETCURSOR`.
+#[derive(Debug, Clone, Copy)]
+pub struct Cursor(pub *const winapi::ctypes::wchar_t);
+unsafe impl Send for Cursor {}
+unsafe impl Sync for Cursor {}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId(u32);
+
+impl DeviceId {
+    pub fn get_persistent_identifier(&self) -> Option<String> {
+        if self.0 != 0 {
+            raw_input::get_raw_input_device_name(self.0 as _)
+        } else {
+            None
+        }
+    }
+}
+
+// Constant device ID, to be removed when this backend is updated to report real device IDs.
+const DEVICE_ID: ::DeviceId = ::DeviceId(DeviceId(0));
+
+fn wrap_device_id(id: u32) -> ::DeviceId {
+    ::DeviceId(DeviceId(id))
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WindowId(HWND);
+unsafe impl Send for WindowId {}
+unsafe impl Sync for WindowId {}
+
+mod dpi;
+mod drop_handler;
+mod event;
+mod events_loop;
+mod icon;
+mod monitor;
+mod raw_input;
+mod util;
+mod window;

src/platform_impl/windows/monitor.rs

@@ -0,0 +1,173 @@
+use winapi::shared::minwindef::{BOOL, DWORD, LPARAM, TRUE};
+use winapi::shared::windef::{HDC, HMONITOR, HWND, LPRECT, POINT};
+use winapi::um::winnt::LONG;
+use winapi::um::winuser;
+
+use std::{mem, ptr};
+use std::collections::VecDeque;
+
+use super::{EventLoop, util};
+use dpi::{PhysicalPosition, PhysicalSize};
+use platform_impl::platform::dpi::{dpi_to_scale_factor, get_monitor_dpi};
+use platform_impl::platform::window::Window;
+
+/// Win32 implementation of the main `MonitorId` object.
+#[derive(Debug, Clone)]
+pub struct MonitorId {
+    /// Monitor handle.
+    hmonitor: HMonitor,
+    /// The system name of the monitor.
+    monitor_name: String,
+    /// True if this is the primary monitor.
+    primary: bool,
+    /// The position of the monitor in pixels on the desktop.
+    ///
+    /// A window that is positioned at these coordinates will overlap the monitor.
+    position: (i32, i32),
+    /// The current resolution in pixels on the monitor.
+    dimensions: (u32, u32),
+    /// DPI scale factor.
+    hidpi_factor: f64,
+}
+
+// Send is not implemented for HMONITOR, we have to wrap it and implement it manually.
+// For more info see:
+// https://github.com/retep998/winapi-rs/issues/360
+// https://github.com/retep998/winapi-rs/issues/396
+#[derive(Debug, Clone)]
+struct HMonitor(HMONITOR);
+
+unsafe impl Send for HMonitor {}
+
+unsafe extern "system" fn monitor_enum_proc(
+    hmonitor: HMONITOR,
+    _hdc: HDC,
+    _place: LPRECT,
+    data: LPARAM,
+) -> BOOL {
+    let monitors = data as *mut VecDeque<MonitorId>;
+    (*monitors).push_back(MonitorId::from_hmonitor(hmonitor));
+    TRUE // continue enumeration
+}
+
+pub fn get_available_monitors() -> VecDeque<MonitorId> {
+    let mut monitors: VecDeque<MonitorId> = VecDeque::new();
+    unsafe {
+        winuser::EnumDisplayMonitors(
+            ptr::null_mut(),
+            ptr::null_mut(),
+            Some(monitor_enum_proc),
+            &mut monitors as *mut _ as LPARAM,
+        );
+    }
+    monitors
+}
+
+pub fn get_primary_monitor() -> MonitorId {
+    const ORIGIN: POINT = POINT { x: 0, y: 0 };
+    let hmonitor = unsafe {
+        winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY)
+    };
+    MonitorId::from_hmonitor(hmonitor)
+}
+
+pub fn get_current_monitor(hwnd: HWND) -> MonitorId {
+    let hmonitor = unsafe {
+        winuser::MonitorFromWindow(hwnd, winuser::MONITOR_DEFAULTTONEAREST)
+    };
+    MonitorId::from_hmonitor(hmonitor)
+}
+
+impl<T> EventLoop<T> {
+    // TODO: Investigate opportunities for caching
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        get_primary_monitor()
+    }
+}
+
+impl Window {
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        get_primary_monitor()
+    }
+}
+
+fn get_monitor_info(hmonitor: HMONITOR) -> Result<winuser::MONITORINFOEXW, util::WinError> {
+    let mut monitor_info: winuser::MONITORINFOEXW = unsafe { mem::uninitialized() };
+    monitor_info.cbSize = mem::size_of::<winuser::MONITORINFOEXW>() as DWORD;
+    let status = unsafe {
+        winuser::GetMonitorInfoW(
+            hmonitor,
+            &mut monitor_info as *mut winuser::MONITORINFOEXW as *mut winuser::MONITORINFO,
+        )
+    };
+    if status == 0 {
+        Err(util::WinError::from_last_error())
+    } else {
+        Ok(monitor_info)
+    }
+}
+
+impl MonitorId {
+    pub(crate) fn from_hmonitor(hmonitor: HMONITOR) -> Self {
+        let monitor_info = get_monitor_info(hmonitor).expect("`GetMonitorInfoW` failed");
+        let place = monitor_info.rcMonitor;
+        let dimensions = (
+            (place.right - place.left) as u32,
+            (place.bottom - place.top) as u32,
+        );
+        MonitorId {
+            hmonitor: HMonitor(hmonitor),
+            monitor_name: util::wchar_ptr_to_string(monitor_info.szDevice.as_ptr()),
+            primary: util::has_flag(monitor_info.dwFlags, winuser::MONITORINFOF_PRIMARY),
+            position: (place.left as i32, place.top as i32),
+            dimensions,
+            hidpi_factor: dpi_to_scale_factor(get_monitor_dpi(hmonitor).unwrap_or(96)),
+        }
+    }
+
+    pub(crate) fn contains_point(&self, point: &POINT) -> bool {
+        let left = self.position.0 as LONG;
+        let right = left + self.dimensions.0 as LONG;
+        let top = self.position.1 as LONG;
+        let bottom = top + self.dimensions.1 as LONG;
+        point.x >= left && point.x <= right && point.y >= top && point.y <= bottom
+    }
+
+    #[inline]
+    pub fn get_name(&self) -> Option<String> {
+        Some(self.monitor_name.clone())
+    }
+
+    #[inline]
+    pub fn get_native_identifier(&self) -> String {
+        self.monitor_name.clone()
+    }
+
+    #[inline]
+    pub fn get_hmonitor(&self) -> HMONITOR {
+        self.hmonitor.0
+    }
+
+    #[inline]
+    pub fn get_dimensions(&self) -> PhysicalSize {
+        self.dimensions.into()
+    }
+
+    #[inline]
+    pub fn get_position(&self) -> PhysicalPosition {
+        self.position.into()
+    }
+
+    #[inline]
+    pub fn get_hidpi_factor(&self) -> f64 {
+        self.hidpi_factor
+    }
+}

src/platform_impl/windows/raw_input.rs

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

src/platform_impl/windows/util.rs

@@ -0,0 +1,104 @@
+use std::{self, mem, ptr, slice};
+use std::ops::BitAnd;
+
+use winapi::ctypes::wchar_t;
+use winapi::shared::minwindef::{BOOL, DWORD};
+use winapi::shared::windef::{HWND, POINT, RECT};
+use winapi::um::errhandlingapi::GetLastError;
+use winapi::um::winbase::{
+    FormatMessageW,
+    FORMAT_MESSAGE_ALLOCATE_BUFFER,
+    FORMAT_MESSAGE_FROM_SYSTEM,
+    FORMAT_MESSAGE_IGNORE_INSERTS,
+    lstrlenW,
+    LocalFree,
+};
+use winapi::um::winnt::{
+    LPCWSTR,
+    MAKELANGID,
+    LANG_NEUTRAL,
+    SUBLANG_DEFAULT,
+};
+use winapi::um::winuser;
+
+pub fn has_flag<T>(bitset: T, flag: T) -> bool
+where T:
+    Copy + PartialEq + BitAnd<T, Output = T>
+{
+    bitset & flag == flag
+}
+
+pub fn wchar_to_string(wchar: &[wchar_t]) -> String {
+    String::from_utf16_lossy(wchar).to_string()
+}
+
+pub fn wchar_ptr_to_string(wchar: *const wchar_t) -> String {
+    let len = unsafe { lstrlenW(wchar) } as usize;
+    let wchar_slice = unsafe { slice::from_raw_parts(wchar, len) };
+    wchar_to_string(wchar_slice)
+}
+
+pub unsafe fn status_map<T, F: FnMut(&mut T) -> BOOL>(mut fun: F) -> Option<T> {
+    let mut data: T = mem::uninitialized();
+    if fun(&mut data) != 0 {
+        Some(data)
+    } else {
+        None
+    }
+}
+
+pub fn get_cursor_pos() -> Option<POINT> {
+    unsafe { status_map(|cursor_pos| winuser::GetCursorPos(cursor_pos)) }
+}
+
+pub fn get_window_rect(hwnd: HWND) -> Option<RECT> {
+    unsafe { status_map(|rect| winuser::GetWindowRect(hwnd, rect)) }
+}
+
+// This won't be needed anymore if we just add a derive to winapi.
+pub fn rect_eq(a: &RECT, b: &RECT) -> bool {
+    let left_eq = a.left == b.left;
+    let right_eq = a.right == b.right;
+    let top_eq = a.top == b.top;
+    let bottom_eq = a.bottom == b.bottom;
+    left_eq && right_eq && top_eq && bottom_eq
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct WinError(Option<String>);
+
+impl WinError {
+    pub fn from_last_error() -> Self {
+        WinError(unsafe { get_last_error() })
+    }
+}
+
+pub unsafe fn get_last_error() -> Option<String> {
+    let err = GetLastError();
+    if err != 0 {
+        let buf_addr: LPCWSTR = {
+            let mut buf_addr: LPCWSTR = mem::uninitialized();
+            FormatMessageW(
+               FORMAT_MESSAGE_ALLOCATE_BUFFER
+               | FORMAT_MESSAGE_FROM_SYSTEM
+               | FORMAT_MESSAGE_IGNORE_INSERTS,
+               ptr::null(),
+               err,
+               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT) as DWORD,
+               // This is a pointer to a pointer
+               &mut buf_addr as *mut LPCWSTR as *mut _,
+               0,
+               ptr::null_mut(),
+            );
+            buf_addr
+        };
+        if !buf_addr.is_null() {
+            let buf_len = lstrlenW(buf_addr) as usize;
+            let buf_slice = std::slice::from_raw_parts(buf_addr, buf_len);
+            let string = wchar_to_string(buf_slice);
+            LocalFree(buf_addr as *mut _);
+            return Some(string);
+        }
+    }
+    None
+}