Fixing the edition warnigns on Windows.

Author: Narsil

src/windows/common.rs

@@ -24,31 +24,31 @@ lazy_static! {
     pub(crate) static ref KEYBOARD: Mutex<Keyboard> = Mutex::new(Keyboard::new().unwrap());
 }
 
-pub unsafe fn get_code(lpdata: LPARAM) -> DWORD {
+pub unsafe fn get_code(lpdata: LPARAM) -> DWORD { unsafe {
     let kb = *(lpdata as *const KBDLLHOOKSTRUCT);
     kb.vkCode
-}
-pub unsafe fn get_scan_code(lpdata: LPARAM) -> DWORD {
+}}
+pub unsafe fn get_scan_code(lpdata: LPARAM) -> DWORD { unsafe {
     let kb = *(lpdata as *const KBDLLHOOKSTRUCT);
     kb.scanCode
-}
-pub unsafe fn get_point(lpdata: LPARAM) -> (LONG, LONG) {
+}}
+pub unsafe fn get_point(lpdata: LPARAM) -> (LONG, LONG) { unsafe {
     let mouse = *(lpdata as *const MSLLHOOKSTRUCT);
     (mouse.pt.x, mouse.pt.y)
-}
+}}
 // https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644986(v=vs.85)
 /// confusingly, this function returns a WORD (unsigned), but may be
 /// interpreted as either signed or unsigned depending on context
-pub unsafe fn get_delta(lpdata: LPARAM) -> WORD {
+pub unsafe fn get_delta(lpdata: LPARAM) -> WORD { unsafe {
     let mouse = *(lpdata as *const MSLLHOOKSTRUCT);
     HIWORD(mouse.mouseData)
-}
-pub unsafe fn get_button_code(lpdata: LPARAM) -> WORD {
+}}
+pub unsafe fn get_button_code(lpdata: LPARAM) -> WORD { unsafe {
     let mouse = *(lpdata as *const MSLLHOOKSTRUCT);
     HIWORD(mouse.mouseData)
-}
+}}
 
-pub unsafe fn convert(param: WPARAM, lpdata: LPARAM) -> Option<EventType> {
+pub unsafe fn convert(param: WPARAM, lpdata: LPARAM) -> Option<EventType> { unsafe {
     match param.try_into() {
         Ok(WM_KEYDOWN) | Ok(WM_SYSKEYDOWN) => {
             let code = get_code(lpdata);
@@ -97,15 +97,15 @@ pub unsafe fn convert(param: WPARAM, lpdata: LPARAM) -> Option<EventType> {
         }
         _ => None,
     }
-}
+}}
 
 type RawCallback = unsafe extern "system" fn(code: c_int, param: WPARAM, lpdata: LPARAM) -> LRESULT;
 pub enum HookError {
     Mouse(DWORD),
     Key(DWORD),
 }
 
-pub unsafe fn set_key_hook(callback: RawCallback) -> Result<(), HookError> {
+pub unsafe fn set_key_hook(callback: RawCallback) -> Result<(), HookError> { unsafe {
     let hook = SetWindowsHookExA(WH_KEYBOARD_LL, Some(callback), null_mut(), 0);
 
     if hook.is_null() {
@@ -114,14 +114,14 @@ pub unsafe fn set_key_hook(callback: RawCallback) -> Result<(), HookError> {
     }
     HOOK = hook;
     Ok(())
-}
+}}
 
-pub unsafe fn set_mouse_hook(callback: RawCallback) -> Result<(), HookError> {
+pub unsafe fn set_mouse_hook(callback: RawCallback) -> Result<(), HookError> { unsafe {
     let hook = SetWindowsHookExA(WH_MOUSE_LL, Some(callback), null_mut(), 0);
     if hook.is_null() {
         let error = GetLastError();
         return Err(HookError::Mouse(error));
     }
     HOOK = hook;
     Ok(())
-}
+}}

src/windows/grab.rs

@@ -6,7 +6,7 @@ use winapi::um::winuser::{CallNextHookEx, GetMessageA, HC_ACTION};
 
 static mut GLOBAL_CALLBACK: Option<Box<dyn FnMut(Event) -> Option<Event>>> = None;
 
-unsafe extern "system" fn raw_callback(code: i32, param: usize, lpdata: isize) -> isize {
+unsafe extern "system" fn raw_callback(code: i32, param: usize, lpdata: isize) -> isize { unsafe {
     if code == HC_ACTION {
         let opt = convert(param, lpdata);
         if let Some(event_type) = opt {
@@ -35,7 +35,7 @@ unsafe extern "system" fn raw_callback(code: i32, param: usize, lpdata: isize) -
         }
     }
     CallNextHookEx(HOOK, code, param, lpdata)
-}
+}}
 impl From<HookError> for GrabError {
     fn from(error: HookError) -> Self {
         match error {

src/windows/keyboard.rs

@@ -33,17 +33,17 @@ impl Keyboard {
         })
     }
 
-    pub(crate) unsafe fn get_name(&mut self, lpdata: LPARAM) -> Option<String> {
+    pub(crate) unsafe fn get_name(&mut self, lpdata: LPARAM) -> Option<String> { unsafe {
         // https://gist.github.com/akimsko/2011327
         // https://www.experts-exchange.com/questions/23453780/LowLevel-Keystroke-Hook-removes-Accents-on-French-Keyboard.html
         let code = get_code(lpdata);
         let scan_code = get_scan_code(lpdata);
 
         self.set_global_state()?;
         self.get_code_name(code, scan_code)
-    }
+    }}
 
-    pub(crate) unsafe fn set_global_state(&mut self) -> Option<()> {
+    pub(crate) unsafe fn set_global_state(&mut self) -> Option<()> { unsafe {
         let mut state = [0_u8; 256];
         let state_ptr = state.as_mut_ptr();
 
@@ -68,9 +68,9 @@ impl Keyboard {
         }
         self.last_state = state;
         Some(())
-    }
+    }}
 
-    pub(crate) unsafe fn get_code_name(&mut self, code: UINT, scan_code: UINT) -> Option<String> {
+    pub(crate) unsafe fn get_code_name(&mut self, code: UINT, scan_code: UINT) -> Option<String> { unsafe {
         let current_window_thread_id = GetWindowThreadProcessId(GetForegroundWindow(), null_mut());
         let state_ptr = self.last_state.as_mut_ptr();
         const BUF_LEN: i32 = 32;
@@ -111,9 +111,9 @@ impl Keyboard {
             self.last_is_dead = is_dead;
         }
         result
-    }
+    }}
 
-    unsafe fn clear_keyboard_buffer(&self, code: UINT, scan_code: UINT, layout: HKL) {
+    unsafe fn clear_keyboard_buffer(&self, code: UINT, scan_code: UINT, layout: HKL) { unsafe {
         const BUF_LEN: i32 = 32;
         let mut buff = [0_u16; BUF_LEN as usize];
         let buff_ptr = buff.as_mut_ptr();
@@ -124,7 +124,7 @@ impl Keyboard {
         while len < 0 {
             len = ToUnicodeEx(code, scan_code, state_ptr, buff_ptr, BUF_LEN, 0, layout);
         }
-    }
+    }}
 }
 
 impl KeyboardState for Keyboard {

src/windows/keycodes.rs

@@ -158,7 +158,7 @@ mod test {
             if let Some(code2) = code_from_key(key) {
                 assert_eq!(code, code2)
             } else {
-                assert!(false, "We could not convert back code: {:?}", code);
+                panic!("We could not convert back code: {:?}", code);
             }
         }
     }

src/windows/listen.rs

@@ -17,7 +17,7 @@ impl From<HookError> for ListenError {
     }
 }
 
-unsafe extern "system" fn raw_callback(code: c_int, param: WPARAM, lpdata: LPARAM) -> LRESULT {
+unsafe extern "system" fn raw_callback(code: c_int, param: WPARAM, lpdata: LPARAM) -> LRESULT { unsafe {
     if code == HC_ACTION {
         let opt = convert(param, lpdata);
         if let Some(event_type) = opt {
@@ -40,7 +40,7 @@ unsafe extern "system" fn raw_callback(code: c_int, param: WPARAM, lpdata: LPARA
         }
     }
     CallNextHookEx(HOOK, code, param, lpdata)
-}
+}}
 
 pub fn listen<T>(callback: T) -> Result<(), ListenError>
 where