diff --git a/src/platform_impl/windows/dpi.rs b/src/platform_impl/windows/dpi.rs index e1a5f0ae..0ff980a2 100644 --- a/src/platform_impl/windows/dpi.rs +++ b/src/platform_impl/windows/dpi.rs @@ -78,36 +78,36 @@ pub fn dpi_to_scale_factor(dpi: u32) -> f64 { } pub unsafe fn hwnd_dpi(hwnd: HWND) -> u32 { - let hdc = GetDC(hwnd); + let hdc = unsafe { GetDC(hwnd) }; if hdc == 0 { 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) { + match unsafe { GetDpiForWindow(hwnd) } { 0 => BASE_DPI, // 0 is returned if hwnd is invalid dpi => dpi, } } else if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR { // We are on Windows 8.1 or later. - let monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST); + let monitor = unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) }; if monitor == 0 { 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 { + if unsafe { GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) } == S_OK { dpi_x } else { BASE_DPI } } else { // We are on Vista or later. - if IsProcessDPIAware() != false.into() { + if unsafe { IsProcessDPIAware() } != false.into() { // If the process is DPI aware, then scaling must be handled by the application using // this DPI value. - GetDeviceCaps(hdc, LOGPIXELSX) as u32 + unsafe { 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 diff --git a/src/platform_impl/windows/drop_handler.rs b/src/platform_impl/windows/drop_handler.rs index 84bebbd1..1326fa99 100644 --- a/src/platform_impl/windows/drop_handler.rs +++ b/src/platform_impl/windows/drop_handler.rs @@ -69,17 +69,17 @@ impl FileDropHandler { } pub unsafe extern "system" fn AddRef(this: *mut IUnknown) -> u32 { - let drop_handler_data = Self::from_interface(this); + let drop_handler_data = unsafe { Self::from_interface(this) }; let count = drop_handler_data.refcount.fetch_add(1, Ordering::Release) + 1; count as u32 } pub unsafe extern "system" fn Release(this: *mut IUnknown) -> u32 { - let drop_handler = Self::from_interface(this); + let drop_handler = unsafe { Self::from_interface(this) }; let count = drop_handler.refcount.fetch_sub(1, Ordering::Release) - 1; if count == 0 { // Destroy the underlying data - drop(Box::from_raw(drop_handler as *mut FileDropHandlerData)); + drop(unsafe { Box::from_raw(drop_handler as *mut FileDropHandlerData) }); } count as u32 } @@ -92,20 +92,24 @@ impl FileDropHandler { pdwEffect: *mut u32, ) -> HRESULT { use crate::event::WindowEvent::HoveredFile; - let drop_handler = Self::from_interface(this); - let hdrop = Self::iterate_filenames(pDataObj, |filename| { - drop_handler.send_event(Event::WindowEvent { - window_id: RootWindowId(WindowId(drop_handler.window)), - event: HoveredFile(filename), - }); - }); + let drop_handler = unsafe { Self::from_interface(this) }; + let hdrop = unsafe { + Self::iterate_filenames(pDataObj, |filename| { + drop_handler.send_event(Event::WindowEvent { + window_id: RootWindowId(WindowId(drop_handler.window)), + event: HoveredFile(filename), + }); + }) + }; drop_handler.hovered_is_valid = hdrop.is_some(); drop_handler.cursor_effect = if drop_handler.hovered_is_valid { DROPEFFECT_COPY } else { DROPEFFECT_NONE }; - *pdwEffect = drop_handler.cursor_effect; + unsafe { + *pdwEffect = drop_handler.cursor_effect; + } S_OK } @@ -116,15 +120,17 @@ impl FileDropHandler { _pt: *const POINTL, pdwEffect: *mut u32, ) -> HRESULT { - let drop_handler = Self::from_interface(this); - *pdwEffect = drop_handler.cursor_effect; + let drop_handler = unsafe { Self::from_interface(this) }; + unsafe { + *pdwEffect = drop_handler.cursor_effect; + } S_OK } pub unsafe extern "system" fn DragLeave(this: *mut IDropTarget) -> HRESULT { use crate::event::WindowEvent::HoveredFileCancelled; - let drop_handler = Self::from_interface(this); + 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)), @@ -143,22 +149,24 @@ impl FileDropHandler { _pdwEffect: *mut u32, ) -> HRESULT { use crate::event::WindowEvent::DroppedFile; - let drop_handler = Self::from_interface(this); - let hdrop = Self::iterate_filenames(pDataObj, |filename| { - drop_handler.send_event(Event::WindowEvent { - window_id: RootWindowId(WindowId(drop_handler.window)), - event: DroppedFile(filename), - }); - }); + let drop_handler = unsafe { Self::from_interface(this) }; + let hdrop = unsafe { + Self::iterate_filenames(pDataObj, |filename| { + drop_handler.send_event(Event::WindowEvent { + window_id: RootWindowId(WindowId(drop_handler.window)), + event: DroppedFile(filename), + }); + }) + }; if let Some(hdrop) = hdrop { - DragFinish(hdrop); + unsafe { DragFinish(hdrop) }; } S_OK } unsafe fn from_interface<'a, InterfaceT>(this: *mut InterfaceT) -> &'a mut FileDropHandlerData { - &mut *(this as *mut _) + unsafe { &mut *(this as *mut _) } } unsafe fn iterate_filenames(data_obj: *const IDataObject, callback: F) -> Option @@ -173,26 +181,29 @@ impl FileDropHandler { tymed: TYMED_HGLOBAL as u32, }; - let mut medium = std::mem::zeroed(); - let get_data_fn = (*(*data_obj).cast::()).GetData; - let get_data_result = get_data_fn(data_obj as *mut _, &drop_format, &mut medium); + let mut medium = unsafe { std::mem::zeroed() }; + let get_data_fn = unsafe { (*(*data_obj).cast::()).GetData }; + let get_data_result = unsafe { get_data_fn(data_obj as *mut _, &drop_format, &mut medium) }; if get_data_result >= 0 { - let hdrop = medium.Anonymous.hGlobal; + let hdrop = unsafe { medium.Anonymous.hGlobal }; // The second parameter (0xFFFFFFFF) instructs the function to return the item count - let item_count = DragQueryFileW(hdrop, 0xFFFFFFFF, ptr::null_mut(), 0); + let item_count = unsafe { DragQueryFileW(hdrop, 0xFFFFFFFF, ptr::null_mut(), 0) }; for i in 0..item_count { // Get the length of the path string NOT including the terminating null character. // Previously, this was using a fixed size array of MAX_PATH length, but the // Windows API allows longer paths under certain circumstances. - let character_count = DragQueryFileW(hdrop, i, ptr::null_mut(), 0) as usize; + let character_count = + unsafe { DragQueryFileW(hdrop, i, ptr::null_mut(), 0) as usize }; let str_len = character_count + 1; // Fill path_buf with the null-terminated file name let mut path_buf = Vec::with_capacity(str_len); - DragQueryFileW(hdrop, i, path_buf.as_mut_ptr(), str_len as u32); - path_buf.set_len(str_len); + unsafe { + DragQueryFileW(hdrop, i, path_buf.as_mut_ptr(), str_len as u32); + path_buf.set_len(str_len); + } callback(OsString::from_wide(&path_buf[0..character_count]).into()); } diff --git a/src/platform_impl/windows/event_loop.rs b/src/platform_impl/windows/event_loop.rs index b5a15ba3..b74e53e2 100644 --- a/src/platform_impl/windows/event_loop.rs +++ b/src/platform_impl/windows/event_loop.rs @@ -145,7 +145,7 @@ pub(crate) struct WindowData { } impl WindowData { - unsafe fn send_event(&self, event: Event) { + fn send_event(&self, event: Event) { self.event_loop_runner.send_event(event); } @@ -160,7 +160,7 @@ struct ThreadMsgTargetData { } impl ThreadMsgTargetData { - unsafe fn send_event(&self, event: Event) { + fn send_event(&self, event: Event) { self.event_loop_runner.send_event(event); } } @@ -596,7 +596,7 @@ fn main_thread_id() -> u32 { #[link_section = ".CRT$XCU"] static INIT_MAIN_THREAD_ID: unsafe fn() = { unsafe fn initer() { - MAIN_THREAD_ID = GetCurrentThreadId(); + unsafe { MAIN_THREAD_ID = GetCurrentThreadId() }; } initer }; @@ -884,7 +884,7 @@ fn insert_event_target_window_data( /// the window. unsafe fn capture_mouse(window: HWND, window_state: &mut WindowState) { window_state.mouse.capture_count += 1; - SetCapture(window); + unsafe { SetCapture(window) }; } /// Release mouse input, stopping windows on this thread from receiving mouse input when the cursor @@ -894,7 +894,7 @@ unsafe fn release_mouse(mut window_state: MutexGuard<'_, WindowState>) { if window_state.mouse.capture_count == 0 { // ReleaseCapture() causes a WM_CAPTURECHANGED where we lock the window_state. drop(window_state); - ReleaseCapture(); + unsafe { ReleaseCapture() }; } } @@ -922,12 +922,10 @@ fn update_modifiers(window: HWND, userdata: &WindowData) { // Drop lock drop(window_state); - unsafe { - userdata.send_event(Event::WindowEvent { - window_id: RootWindowId(WindowId(window)), - event: ModifiersChanged(modifiers.into()), - }); - } + userdata.send_event(Event::WindowEvent { + window_id: RootWindowId(WindowId(window)), + event: ModifiersChanged(modifiers.into()), + }); } } @@ -970,18 +968,18 @@ pub(super) unsafe extern "system" fn public_window_callback( wparam: WPARAM, lparam: LPARAM, ) -> LRESULT { - let userdata = super::get_window_long(window, GWL_USERDATA); + let userdata = unsafe { super::get_window_long(window, GWL_USERDATA) }; let userdata_ptr = match (userdata, msg) { (0, WM_NCCREATE) => { - let createstruct = &mut *(lparam as *mut CREATESTRUCTW); - let initdata = &mut *(createstruct.lpCreateParams as *mut InitData<'_, T>); + let createstruct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) }; + let initdata = unsafe { &mut *(createstruct.lpCreateParams as *mut InitData<'_, T>) }; - let result = match initdata.on_nccreate(window) { - Some(userdata) => { + let result = match unsafe { initdata.on_nccreate(window) } { + Some(userdata) => unsafe { super::set_window_long(window, GWL_USERDATA, userdata as _); DefWindowProcW(window, msg, wparam, lparam) - } + }, None => -1, // failed to create the window }; @@ -990,24 +988,24 @@ pub(super) unsafe extern "system" fn public_window_callback( // Getting here should quite frankly be impossible, // but we'll make window creation fail here just in case. (0, WM_CREATE) => return -1, - (_, WM_CREATE) => { + (_, WM_CREATE) => unsafe { let createstruct = &mut *(lparam as *mut CREATESTRUCTW); let initdata = createstruct.lpCreateParams; let initdata = &mut *(initdata as *mut InitData<'_, T>); initdata.on_create(); return DefWindowProcW(window, msg, wparam, lparam); - } - (0, _) => return DefWindowProcW(window, msg, wparam, lparam), + }, + (0, _) => return unsafe { DefWindowProcW(window, msg, wparam, lparam) }, _ => userdata as *mut WindowData, }; let (result, userdata_removed, recurse_depth) = { - let userdata = &*(userdata_ptr); + let userdata = unsafe { &*(userdata_ptr) }; userdata.recurse_depth.set(userdata.recurse_depth.get() + 1); - let result = public_window_callback_inner(window, msg, wparam, lparam, userdata); + let result = unsafe { public_window_callback_inner(window, msg, wparam, lparam, userdata) }; let userdata_removed = userdata.userdata_removed.get(); let recurse_depth = userdata.recurse_depth.get() - 1; @@ -1017,7 +1015,7 @@ pub(super) unsafe extern "system" fn public_window_callback( }; if userdata_removed && recurse_depth == 0 { - drop(Box::from_raw(userdata_ptr)); + drop(unsafe { Box::from_raw(userdata_ptr) }); } result @@ -1078,7 +1076,7 @@ unsafe fn public_window_callback_inner( return; } - let params = &mut *(lparam as *mut NCCALCSIZE_PARAMS); + let params = unsafe { &mut *(lparam as *mut NCCALCSIZE_PARAMS) }; if util::is_maximized(window) { // Limit the window size when maximized to the current monitor. @@ -1087,7 +1085,7 @@ unsafe fn public_window_callback_inner( // Use `MonitorFromRect` instead of `MonitorFromWindow` to select // the correct monitor here. // See https://github.com/MicrosoftEdge/WebView2Feedback/issues/2549 - let monitor = MonitorFromRect(¶ms.rgrc[0], MONITOR_DEFAULTTONULL); + let monitor = unsafe { MonitorFromRect(¶ms.rgrc[0], MONITOR_DEFAULTTONULL) }; if let Ok(monitor_info) = monitor::get_monitor_info(monitor) { params.rgrc[0] = monitor_info.monitorInfo.rcWork; } @@ -1121,7 +1119,7 @@ unsafe fn public_window_callback_inner( let mut state = userdata.window_state_lock(); if state.dragging { state.dragging = false; - PostMessageW(window, WM_LBUTTONUP, 0, lparam); + unsafe { PostMessageW(window, WM_LBUTTONUP, 0, lparam) }; } state.set_window_flags_in_place(|f| f.remove(WindowFlags::MARKER_IN_SIZE_MOVE)); @@ -1130,7 +1128,7 @@ unsafe fn public_window_callback_inner( WM_NCLBUTTONDOWN => { if wparam == HTCAPTION as _ { - PostMessageW(window, WM_MOUSEMOVE, 0, lparam); + unsafe { PostMessageW(window, WM_MOUSEMOVE, 0, lparam) }; } result = ProcResult::DefWindowProc(wparam); } @@ -1146,7 +1144,7 @@ unsafe fn public_window_callback_inner( WM_DESTROY => { use crate::event::WindowEvent::Destroyed; - RevokeDragDrop(window); + unsafe { RevokeDragDrop(window) }; userdata.send_event(Event::WindowEvent { window_id: RootWindowId(WindowId(window)), event: Destroyed, @@ -1155,7 +1153,7 @@ unsafe fn public_window_callback_inner( } WM_NCDESTROY => { - super::set_window_long(window, GWL_USERDATA, 0); + unsafe { super::set_window_long(window, GWL_USERDATA, 0) }; userdata.userdata_removed.set(true); result = ProcResult::Value(0); } @@ -1164,7 +1162,7 @@ unsafe fn public_window_callback_inner( if userdata.event_loop_runner.should_buffer() { // this branch can happen in response to `UpdateWindow`, if win32 decides to // redraw the window outside the normal flow of the event loop. - RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT); + unsafe { RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT) }; } else { userdata.send_event(Event::WindowEvent { window_id: RootWindowId(WindowId(window)), @@ -1177,7 +1175,7 @@ unsafe fn public_window_callback_inner( WM_WINDOWPOSCHANGING => { let mut window_state = userdata.window_state_lock(); if let Some(ref mut fullscreen) = window_state.fullscreen { - let window_pos = &mut *(lparam as *mut WINDOWPOS); + let window_pos = unsafe { &mut *(lparam as *mut WINDOWPOS) }; let new_rect = RECT { left: window_pos.x, top: window_pos.y, @@ -1215,7 +1213,7 @@ unsafe fn public_window_callback_inner( }; if let Some(new_rect) = new_rect { - let new_monitor = MonitorFromRect(&new_rect, MONITOR_DEFAULTTONULL); + let new_monitor = unsafe { MonitorFromRect(&new_rect, MONITOR_DEFAULTTONULL) }; match fullscreen { Fullscreen::Borderless(ref mut fullscreen_monitor) => { if new_monitor != 0 @@ -1257,8 +1255,9 @@ unsafe fn public_window_callback_inner( use crate::event::WindowEvent::Moved; let windowpos = lparam as *const WINDOWPOS; - if (*windowpos).flags & SWP_NOMOVE != SWP_NOMOVE { - let physical_position = PhysicalPosition::new((*windowpos).x, (*windowpos).y); + if unsafe { (*windowpos).flags & SWP_NOMOVE != SWP_NOMOVE } { + let physical_position = + unsafe { PhysicalPosition::new((*windowpos).x, (*windowpos).y) }; userdata.send_event(Event::WindowEvent { window_id: RootWindowId(WindowId(window)), event: Moved(physical_position), @@ -1321,7 +1320,7 @@ unsafe fn public_window_callback_inner( // Windows Hangul IME sends WM_IME_COMPOSITION after WM_IME_ENDCOMPOSITION, so // check whether composing. if ime_allowed_and_composing { - let ime_context = ImeContext::current(window); + let ime_context = unsafe { ImeContext::current(window) }; if lparam == 0 { userdata.send_event(Event::WindowEvent { @@ -1333,7 +1332,7 @@ unsafe fn public_window_callback_inner( // Google Japanese Input and ATOK have both flags, so // first, receive composing result if exist. if (lparam as u32 & GCS_RESULTSTR) != 0 { - if let Some(text) = ime_context.get_composed_text() { + if let Some(text) = unsafe { ime_context.get_composed_text() } { userdata.window_state_lock().ime_state = ImeState::Enabled; userdata.send_event(Event::WindowEvent { @@ -1349,7 +1348,9 @@ unsafe fn public_window_callback_inner( // Next, receive preedit range for next composing if exist. if (lparam as u32 & GCS_COMPSTR) != 0 { - if let Some((text, first, last)) = ime_context.get_composing_text_and_cursor() { + if let Some((text, first, last)) = + unsafe { ime_context.get_composing_text_and_cursor() } + { userdata.window_state_lock().ime_state = ImeState::Preedit; let cursor_range = first.map(|f| (f, last.unwrap_or(f))); @@ -1374,8 +1375,8 @@ unsafe fn public_window_callback_inner( if userdata.window_state_lock().ime_state == ImeState::Preedit { // Windows Hangul IME sends WM_IME_COMPOSITION after WM_IME_ENDCOMPOSITION, so // trying receiving composing result and commit if exists. - let ime_context = ImeContext::current(window); - if let Some(text) = ime_context.get_composed_text() { + let ime_context = unsafe { ImeContext::current(window) }; + if let Some(text) = unsafe { ime_context.get_composed_text() } { userdata.send_event(Event::WindowEvent { window_id: RootWindowId(WindowId(window)), event: WindowEvent::Ime(Ime::Preedit(String::new(), None)), @@ -1448,12 +1449,14 @@ unsafe fn public_window_callback_inner( }); // Calling TrackMouseEvent in order to receive mouse leave events. - TrackMouseEvent(&mut TRACKMOUSEEVENT { - cbSize: mem::size_of::() as u32, - dwFlags: TME_LEAVE, - hwndTrack: window, - dwHoverTime: HOVER_DEFAULT, - }); + unsafe { + TrackMouseEvent(&mut TRACKMOUSEEVENT { + cbSize: mem::size_of::() as u32, + dwFlags: TME_LEAVE, + hwndTrack: window, + dwHoverTime: HOVER_DEFAULT, + }) + }; } let x = super::get_x_lparam(lparam as u32) as f64; @@ -1551,7 +1554,7 @@ unsafe fn public_window_callback_inner( } WM_KEYUP | WM_SYSKEYUP => { - if msg == WM_SYSKEYUP && GetMenu(window) != 0 { + if msg == WM_SYSKEYUP && unsafe { GetMenu(window) != 0 } { // let Windows handle event if the window has a native menu, a modal event loop // is started here on Alt key up. result = ProcResult::DefWindowProc(wparam); @@ -1561,7 +1564,7 @@ unsafe fn public_window_callback_inner( WM_LBUTTONDOWN => { use crate::event::{ElementState::Pressed, MouseButton::Left, WindowEvent::MouseInput}; - capture_mouse(window, &mut userdata.window_state_lock()); + unsafe { capture_mouse(window, &mut userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1581,7 +1584,7 @@ unsafe fn public_window_callback_inner( ElementState::Released, MouseButton::Left, WindowEvent::MouseInput, }; - release_mouse(userdata.window_state_lock()); + unsafe { release_mouse(userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1601,7 +1604,7 @@ unsafe fn public_window_callback_inner( ElementState::Pressed, MouseButton::Right, WindowEvent::MouseInput, }; - capture_mouse(window, &mut userdata.window_state_lock()); + unsafe { capture_mouse(window, &mut userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1621,7 +1624,7 @@ unsafe fn public_window_callback_inner( ElementState::Released, MouseButton::Right, WindowEvent::MouseInput, }; - release_mouse(userdata.window_state_lock()); + unsafe { release_mouse(userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1641,7 +1644,7 @@ unsafe fn public_window_callback_inner( ElementState::Pressed, MouseButton::Middle, WindowEvent::MouseInput, }; - capture_mouse(window, &mut userdata.window_state_lock()); + unsafe { capture_mouse(window, &mut userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1661,7 +1664,7 @@ unsafe fn public_window_callback_inner( ElementState::Released, MouseButton::Middle, WindowEvent::MouseInput, }; - release_mouse(userdata.window_state_lock()); + unsafe { release_mouse(userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1683,7 +1686,7 @@ unsafe fn public_window_callback_inner( }; let xbutton = super::get_xbutton_wparam(wparam as u32); - capture_mouse(window, &mut userdata.window_state_lock()); + unsafe { capture_mouse(window, &mut userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1709,7 +1712,7 @@ unsafe fn public_window_callback_inner( }; let xbutton = super::get_xbutton_wparam(wparam as u32); - release_mouse(userdata.window_state_lock()); + unsafe { release_mouse(userdata.window_state_lock()) }; update_modifiers(window, userdata); @@ -1743,21 +1746,22 @@ unsafe fn public_window_callback_inner( let pcount = super::loword(wparam as u32) as usize; let mut inputs = Vec::with_capacity(pcount); let htouch = lparam; - if GetTouchInputInfo( - htouch, - pcount as u32, - inputs.as_mut_ptr(), - mem::size_of::() as i32, - ) > 0 - { - inputs.set_len(pcount); + if unsafe { + GetTouchInputInfo( + htouch, + pcount as u32, + inputs.as_mut_ptr(), + mem::size_of::() as i32, + ) > 0 + } { + unsafe { inputs.set_len(pcount) }; for input in &inputs { let mut location = POINT { x: input.x / 100, y: input.y / 100, }; - if ScreenToClient(window, &mut location) == false.into() { + if unsafe { ScreenToClient(window, &mut location) } == false.into() { continue; } @@ -1784,7 +1788,7 @@ unsafe fn public_window_callback_inner( }); } } - CloseTouchInputHandle(htouch); + unsafe { CloseTouchInputHandle(htouch) }; result = ProcResult::Value(0); } @@ -1801,12 +1805,14 @@ unsafe fn public_window_callback_inner( let pointer_id = super::loword(wparam as u32) as u32; let mut entries_count = 0u32; let mut pointers_count = 0u32; - if GetPointerFrameInfoHistory( - pointer_id, - &mut entries_count, - &mut pointers_count, - ptr::null_mut(), - ) == false.into() + if unsafe { + GetPointerFrameInfoHistory( + pointer_id, + &mut entries_count, + &mut pointers_count, + ptr::null_mut(), + ) + } == false.into() { result = ProcResult::Value(0); return; @@ -1814,17 +1820,19 @@ unsafe fn public_window_callback_inner( let pointer_info_count = (entries_count * pointers_count) as usize; let mut pointer_infos = Vec::with_capacity(pointer_info_count); - if GetPointerFrameInfoHistory( - pointer_id, - &mut entries_count, - &mut pointers_count, - pointer_infos.as_mut_ptr(), - ) == false.into() + if unsafe { + GetPointerFrameInfoHistory( + pointer_id, + &mut entries_count, + &mut pointers_count, + pointer_infos.as_mut_ptr(), + ) + } == false.into() { result = ProcResult::Value(0); return; } - pointer_infos.set_len(pointer_info_count); + unsafe { pointer_infos.set_len(pointer_info_count) }; // https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getpointerframeinfohistory // The information retrieved appears in reverse chronological order, with the most recent entry in the first @@ -1833,17 +1841,19 @@ unsafe fn public_window_callback_inner( let mut device_rect = mem::MaybeUninit::uninit(); let mut display_rect = mem::MaybeUninit::uninit(); - if GetPointerDeviceRects( - pointer_info.sourceDevice, - device_rect.as_mut_ptr(), - display_rect.as_mut_ptr(), - ) == false.into() + if unsafe { + GetPointerDeviceRects( + pointer_info.sourceDevice, + device_rect.as_mut_ptr(), + display_rect.as_mut_ptr(), + ) + } == false.into() { continue; } - let device_rect = device_rect.assume_init(); - let display_rect = display_rect.assume_init(); + let device_rect = unsafe { device_rect.assume_init() }; + let display_rect = unsafe { display_rect.assume_init() }; // For the most precise himetric to pixel conversion we calculate the ratio between the resolution // of the display device (pixel) and the touch device (himetric). @@ -1865,7 +1875,7 @@ unsafe fn public_window_callback_inner( y: y.floor() as i32, }; - if ScreenToClient(window, &mut location) == false.into() { + if unsafe { ScreenToClient(window, &mut location) } == false.into() { continue; } @@ -1873,28 +1883,29 @@ unsafe fn public_window_callback_inner( PT_TOUCH => { let mut touch_info = mem::MaybeUninit::uninit(); GET_POINTER_TOUCH_INFO.and_then(|GetPointerTouchInfo| { - match GetPointerTouchInfo( - pointer_info.pointerId, - touch_info.as_mut_ptr(), - ) { + match unsafe { + GetPointerTouchInfo( + pointer_info.pointerId, + touch_info.as_mut_ptr(), + ) + } { 0 => None, - _ => normalize_pointer_pressure( - touch_info.assume_init().pressure, - ), + _ => normalize_pointer_pressure(unsafe { + touch_info.assume_init().pressure + }), } }) } PT_PEN => { let mut pen_info = mem::MaybeUninit::uninit(); GET_POINTER_PEN_INFO.and_then(|GetPointerPenInfo| { - match GetPointerPenInfo( - pointer_info.pointerId, - pen_info.as_mut_ptr(), - ) { + match unsafe { + GetPointerPenInfo(pointer_info.pointerId, pen_info.as_mut_ptr()) + } { 0 => None, - _ => { - normalize_pointer_pressure(pen_info.assume_init().pressure) - } + _ => normalize_pointer_pressure(unsafe { + pen_info.assume_init().pressure + }), } }) } @@ -1925,7 +1936,7 @@ unsafe fn public_window_callback_inner( }); } - SkipPointerFrameMessages(pointer_id); + unsafe { SkipPointerFrameMessages(pointer_id) }; } result = ProcResult::Value(0); } @@ -1935,9 +1946,9 @@ unsafe fn public_window_callback_inner( let active_focus_changed = userdata.window_state_lock().set_active(is_active); if active_focus_changed { if is_active { - gain_active_focus(window, userdata); + unsafe { gain_active_focus(window, userdata) }; } else { - lose_active_focus(window, userdata); + unsafe { lose_active_focus(window, userdata) }; } } result = ProcResult::DefWindowProc(wparam); @@ -1946,7 +1957,7 @@ unsafe fn public_window_callback_inner( WM_SETFOCUS => { let active_focus_changed = userdata.window_state_lock().set_focused(true); if active_focus_changed { - gain_active_focus(window, userdata); + unsafe { gain_active_focus(window, userdata) }; } result = ProcResult::Value(0); } @@ -1954,7 +1965,7 @@ unsafe fn public_window_callback_inner( WM_KILLFOCUS => { let active_focus_changed = userdata.window_state_lock().set_focused(false); if active_focus_changed { - lose_active_focus(window, userdata); + unsafe { lose_active_focus(window, userdata) }; } result = ProcResult::Value(0); } @@ -1975,8 +1986,8 @@ unsafe fn public_window_callback_inner( match set_cursor_to { Some(cursor) => { - let cursor = LoadCursorW(0, util::to_windows_cursor(cursor)); - SetCursor(cursor); + let cursor = unsafe { LoadCursorW(0, util::to_windows_cursor(cursor)) }; + unsafe { SetCursor(cursor) }; result = ProcResult::Value(0); } None => result = ProcResult::DefWindowProc(wparam), @@ -1994,18 +2005,22 @@ unsafe fn public_window_callback_inner( let min_size = min_size.to_physical(window_state.scale_factor); let (width, height): (u32, u32) = window_flags.adjust_size(window, min_size).into(); - (*mmi).ptMinTrackSize = POINT { - x: width as i32, - y: height as i32, + unsafe { + (*mmi).ptMinTrackSize = POINT { + x: width as i32, + y: height as i32, + } }; } if let Some(max_size) = window_state.max_size { let max_size = max_size.to_physical(window_state.scale_factor); let (width, height): (u32, u32) = window_flags.adjust_size(window, max_size).into(); - (*mmi).ptMaxTrackSize = POINT { - x: width as i32, - y: height as i32, + unsafe { + (*mmi).ptMaxTrackSize = POINT { + x: width as i32, + y: height as i32, + } }; } } @@ -2043,7 +2058,7 @@ unsafe fn public_window_callback_inner( }; // New size as suggested by Windows. - let suggested_rect = *(lparam as *const RECT); + let suggested_rect = unsafe { *(lparam as *const RECT) }; // The window rect provided is the window's outer size, not it's inner size. However, // win32 doesn't provide an `UnadjustWindowRectEx` function to get the client rect from @@ -2132,8 +2147,8 @@ unsafe fn public_window_callback_inner( if dragging_window { let bias = { let cursor_pos = { - let mut pos = mem::zeroed(); - GetCursorPos(&mut pos); + let mut pos = unsafe { mem::zeroed() }; + unsafe { GetCursorPos(&mut pos) }; pos }; let suggested_cursor_horizontal_ratio = (cursor_pos.x - suggested_rect.left) @@ -2152,18 +2167,18 @@ unsafe fn public_window_callback_inner( // Check to see if the new window rect is on the monitor with the new DPI factor. // If it isn't, offset the window so that it is. - let new_dpi_monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONULL); + let new_dpi_monitor = unsafe { MonitorFromWindow(window, MONITOR_DEFAULTTONULL) }; let conservative_rect_monitor = - MonitorFromRect(&conservative_rect, MONITOR_DEFAULTTONULL); + unsafe { MonitorFromRect(&conservative_rect, MONITOR_DEFAULTTONULL) }; new_outer_rect = if conservative_rect_monitor == new_dpi_monitor { conservative_rect } else { let get_monitor_rect = |monitor| { let mut monitor_info = MONITORINFO { cbSize: mem::size_of::() as _, - ..mem::zeroed() + ..unsafe { mem::zeroed() } }; - GetMonitorInfoW(monitor, &mut monitor_info); + unsafe { GetMonitorInfoW(monitor, &mut monitor_info) }; monitor_info.rcMonitor }; let wrong_monitor = conservative_rect_monitor; @@ -2200,7 +2215,7 @@ unsafe fn public_window_callback_inner( conservative_rect.top += delta_nudge_to_dpi_monitor.1; conservative_rect.bottom += delta_nudge_to_dpi_monitor.1; - if MonitorFromRect(&conservative_rect, MONITOR_DEFAULTTONULL) + if unsafe { MonitorFromRect(&conservative_rect, MONITOR_DEFAULTTONULL) } == new_dpi_monitor { break; @@ -2211,15 +2226,17 @@ unsafe fn public_window_callback_inner( }; } - SetWindowPos( - window, - 0, - new_outer_rect.left, - new_outer_rect.top, - new_outer_rect.right - new_outer_rect.left, - new_outer_rect.bottom - new_outer_rect.top, - SWP_NOZORDER | SWP_NOACTIVATE, - ); + unsafe { + SetWindowPos( + window, + 0, + new_outer_rect.left, + new_outer_rect.top, + new_outer_rect.right - new_outer_rect.left, + new_outer_rect.bottom - new_outer_rect.top, + SWP_NOZORDER | SWP_NOACTIVATE, + ) + }; result = ProcResult::Value(0); } @@ -2247,7 +2264,7 @@ unsafe fn public_window_callback_inner( _ => { if msg == DESTROY_MSG_ID.get() { - DestroyWindow(window); + unsafe { DestroyWindow(window) }; result = ProcResult::Value(0); } else if msg == SET_RETAIN_STATE_ON_SIZE_MSG_ID.get() { let mut window_state = userdata.window_state_lock(); @@ -2257,7 +2274,7 @@ unsafe fn public_window_callback_inner( result = ProcResult::Value(0); } else if msg == TASKBAR_CREATED.get() { let window_state = userdata.window_state_lock(); - set_skip_taskbar(window, window_state.skip_taskbar); + unsafe { set_skip_taskbar(window, window_state.skip_taskbar) }; result = ProcResult::DefWindowProc(wparam); } else { result = ProcResult::DefWindowProc(wparam); @@ -2271,7 +2288,7 @@ unsafe fn public_window_callback_inner( .unwrap_or_else(|| result = ProcResult::Value(-1)); match result { - ProcResult::DefWindowProc(wparam) => DefWindowProcW(window, msg, wparam, lparam), + ProcResult::DefWindowProc(wparam) => unsafe { DefWindowProcW(window, msg, wparam, lparam) }, ProcResult::Value(val) => val, } } @@ -2282,16 +2299,17 @@ unsafe extern "system" fn thread_event_target_callback( wparam: WPARAM, lparam: LPARAM, ) -> LRESULT { - let userdata_ptr = super::get_window_long(window, GWL_USERDATA) as *mut ThreadMsgTargetData; + let userdata_ptr = + unsafe { super::get_window_long(window, GWL_USERDATA) } as *mut ThreadMsgTargetData; if userdata_ptr.is_null() { // `userdata_ptr` will always be null for the first `WM_GETMINMAXINFO`, as well as `WM_NCCREATE` and // `WM_CREATE`. - return DefWindowProcW(window, msg, wparam, lparam); + return unsafe { DefWindowProcW(window, msg, wparam, lparam) }; } - let userdata = Box::from_raw(userdata_ptr); + let userdata = unsafe { Box::from_raw(userdata_ptr) }; if msg != WM_PAINT { - RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT); + unsafe { RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT) }; } let mut userdata_removed = false; @@ -2301,15 +2319,15 @@ unsafe extern "system" fn thread_event_target_callback( // the git blame and history would be preserved. let callback = || match msg { WM_NCDESTROY => { - super::set_window_long(window, GWL_USERDATA, 0); + unsafe { super::set_window_long(window, GWL_USERDATA, 0) }; userdata_removed = true; 0 } - WM_PAINT => { + WM_PAINT => unsafe { ValidateRect(window, ptr::null()); // Default WM_PAINT behaviour. This makes sure modals and popups are shown immediatly when opening them. DefWindowProcW(window, msg, wparam, lparam) - } + }, WM_INPUT_DEVICE_CHANGE => { let event = match wparam as u32 { @@ -2328,10 +2346,10 @@ unsafe extern "system" fn thread_event_target_callback( WM_INPUT => { if let Some(data) = raw_input::get_raw_input_data(lparam as _) { - handle_raw_input(&userdata, data); + unsafe { handle_raw_input(&userdata, data) }; } - DefWindowProcW(window, msg, wparam, lparam) + unsafe { DefWindowProcW(window, msg, wparam, lparam) } } _ if msg == USER_EVENT_MSG_ID.get() => { @@ -2341,11 +2359,11 @@ unsafe extern "system" fn thread_event_target_callback( 0 } _ if msg == EXEC_MSG_ID.get() => { - let mut function: ThreadExecFn = Box::from_raw(wparam as *mut _); + let mut function: ThreadExecFn = unsafe { Box::from_raw(wparam as *mut _) }; function(); 0 } - _ => DefWindowProcW(window, msg, wparam, lparam), + _ => unsafe { DefWindowProcW(window, msg, wparam, lparam) }, }; let result = userdata @@ -2370,7 +2388,7 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: let device_id = wrap_device_id(data.header.hDevice as _); if data.header.dwType == RIM_TYPEMOUSE { - let mouse = data.data.mouse; + let mouse = unsafe { data.data.mouse }; if util::has_flag(mouse.usFlags as u32, MOUSE_MOVE_RELATIVE) { let x = mouse.lLastX as f64; @@ -2398,10 +2416,10 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: } } - let button_flags = mouse.Anonymous.Anonymous.usButtonFlags; + let button_flags = unsafe { mouse.Anonymous.Anonymous.usButtonFlags }; if util::has_flag(button_flags as u32, RI_MOUSE_WHEEL) { - let button_data = mouse.Anonymous.Anonymous.usButtonData; + let button_data = unsafe { mouse.Anonymous.Anonymous.usButtonData }; // We must cast to i16 first, becaues `usButtonData` must be interpreted as signed. let delta = button_data as i16 as f32 / WHEEL_DELTA as f32; userdata.send_event(Event::DeviceEvent { @@ -2427,7 +2445,7 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: } } } else if data.header.dwType == RIM_TYPEKEYBOARD { - let keyboard = data.data.keyboard; + let keyboard = unsafe { data.data.keyboard }; let pressed = keyboard.Message == WM_KEYDOWN || keyboard.Message == WM_SYSKEYDOWN; let released = keyboard.Message == WM_KEYUP || keyboard.Message == WM_SYSKEYUP; @@ -2449,7 +2467,7 @@ unsafe fn handle_raw_input(userdata: &ThreadMsgTargetData, data: let scancode = if keyboard.MakeCode == 0 { // In some cases (often with media keys) the device reports a scancode of 0 but a // valid virtual key. In these cases we obtain the scancode from the virtual key. - MapVirtualKeyW(keyboard.VKey as u32, MAPVK_VK_TO_VSC_EX) as u16 + unsafe { MapVirtualKeyW(keyboard.VKey as u32, MAPVK_VK_TO_VSC_EX) as u16 } } else { keyboard.MakeCode | extension }; diff --git a/src/platform_impl/windows/event_loop/runner.rs b/src/platform_impl/windows/event_loop/runner.rs index d907cc33..d4b935cf 100644 --- a/src/platform_impl/windows/event_loop/runner.rs +++ b/src/platform_impl/windows/event_loop/runner.rs @@ -96,10 +96,12 @@ impl EventLoopRunner { where F: FnMut(Event), { - let old_event_handler = self.event_handler.replace(mem::transmute::< - Option)>>, - Option)>>, - >(Some(Box::new(f)))); + // Erase closure lifetime. + // SAFETY: Caller upholds that the lifetime of the closure is upheld. + let f = unsafe { + mem::transmute::)>, Box)>>(Box::new(f)) + }; + let old_event_handler = self.event_handler.replace(Some(f)); assert!(old_event_handler.is_none()); } diff --git a/src/platform_impl/windows/ime.rs b/src/platform_impl/windows/ime.rs index 2f9320f8..09db3ce4 100644 --- a/src/platform_impl/windows/ime.rs +++ b/src/platform_impl/windows/ime.rs @@ -30,15 +30,15 @@ pub struct ImeContext { impl ImeContext { pub unsafe fn current(hwnd: HWND) -> Self { - let himc = ImmGetContext(hwnd); + let himc = unsafe { ImmGetContext(hwnd) }; ImeContext { hwnd, himc } } pub unsafe fn get_composing_text_and_cursor( &self, ) -> Option<(String, Option, Option)> { - let text = self.get_composition_string(GCS_COMPSTR)?; - let attrs = self.get_composition_data(GCS_COMPATTR).unwrap_or_default(); + let text = unsafe { self.get_composition_string(GCS_COMPSTR) }?; + let attrs = unsafe { self.get_composition_data(GCS_COMPATTR) }.unwrap_or_default(); let mut first = None; let mut last = None; @@ -61,7 +61,7 @@ impl ImeContext { last = Some(text.len()); } else if first.is_none() { // IME haven't split words and select any clause yet, so trying to retrieve normal cursor. - let cursor = self.get_composition_cursor(&text); + let cursor = unsafe { self.get_composition_cursor(&text) }; first = cursor; last = cursor; } @@ -70,17 +70,17 @@ impl ImeContext { } pub unsafe fn get_composed_text(&self) -> Option { - self.get_composition_string(GCS_RESULTSTR) + unsafe { self.get_composition_string(GCS_RESULTSTR) } } unsafe fn get_composition_cursor(&self, text: &str) -> Option { - let cursor = ImmGetCompositionStringW(self.himc, GCS_CURSORPOS, null_mut(), 0); + let cursor = unsafe { ImmGetCompositionStringW(self.himc, GCS_CURSORPOS, null_mut(), 0) }; (cursor >= 0).then(|| text.chars().take(cursor as _).map(|c| c.len_utf8()).sum()) } unsafe fn get_composition_string(&self, gcs_mode: u32) -> Option { - let data = self.get_composition_data(gcs_mode)?; - let (prefix, shorts, suffix) = data.align_to::(); + let data = unsafe { self.get_composition_data(gcs_mode) }?; + let (prefix, shorts, suffix) = unsafe { data.align_to::() }; if prefix.is_empty() && suffix.is_empty() { OsString::from_wide(shorts).into_string().ok() } else { @@ -89,30 +89,32 @@ impl ImeContext { } unsafe fn get_composition_data(&self, gcs_mode: u32) -> Option> { - let size = match ImmGetCompositionStringW(self.himc, gcs_mode, null_mut(), 0) { + let size = match unsafe { ImmGetCompositionStringW(self.himc, gcs_mode, null_mut(), 0) } { 0 => return Some(Vec::new()), size if size < 0 => return None, size => size, }; let mut buf = Vec::::with_capacity(size as _); - let size = ImmGetCompositionStringW( - self.himc, - gcs_mode, - buf.as_mut_ptr() as *mut c_void, - size as _, - ); + let size = unsafe { + ImmGetCompositionStringW( + self.himc, + gcs_mode, + buf.as_mut_ptr() as *mut c_void, + size as _, + ) + }; if size < 0 { None } else { - buf.set_len(size as _); + unsafe { buf.set_len(size as _) }; Some(buf) } } pub unsafe fn set_ime_cursor_area(&self, spot: Position, size: Size, scale_factor: f64) { - if !ImeContext::system_has_ime() { + if !unsafe { ImeContext::system_has_ime() } { return; } @@ -131,23 +133,23 @@ impl ImeContext { rcArea: rc_area, }; - ImmSetCandidateWindow(self.himc, &candidate_form); + unsafe { ImmSetCandidateWindow(self.himc, &candidate_form) }; } pub unsafe fn set_ime_allowed(hwnd: HWND, allowed: bool) { - if !ImeContext::system_has_ime() { + if !unsafe { ImeContext::system_has_ime() } { return; } if allowed { - ImmAssociateContextEx(hwnd, 0, IACE_DEFAULT); + unsafe { ImmAssociateContextEx(hwnd, 0, IACE_DEFAULT) }; } else { - ImmAssociateContextEx(hwnd, 0, IACE_CHILDREN); + unsafe { ImmAssociateContextEx(hwnd, 0, IACE_CHILDREN) }; } } unsafe fn system_has_ime() -> bool { - GetSystemMetrics(SM_IMMENABLED) != 0 + unsafe { GetSystemMetrics(SM_IMMENABLED) != 0 } } } diff --git a/src/platform_impl/windows/mod.rs b/src/platform_impl/windows/mod.rs index 045baa76..87f155e5 100644 --- a/src/platform_impl/windows/mod.rs +++ b/src/platform_impl/windows/mod.rs @@ -1,4 +1,5 @@ #![cfg(windows_platform)] +#![deny(unsafe_op_in_unsafe_fn)] use smol_str::SmolStr; use windows_sys::Win32::{ @@ -154,21 +155,24 @@ const fn hiword(x: u32) -> u16 { #[inline(always)] unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize { #[cfg(target_pointer_width = "64")] - return windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex); + return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) }; #[cfg(target_pointer_width = "32")] - return windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize; + return unsafe { + windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize + }; } #[inline(always)] unsafe fn set_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX, dwnewlong: isize) -> isize { #[cfg(target_pointer_width = "64")] - return windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong); + return unsafe { + windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong) + }; #[cfg(target_pointer_width = "32")] - return windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW( - hwnd, - nindex, - dwnewlong as i32, - ) as isize; + return unsafe { + windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32) + as isize + }; } #[macro_use] diff --git a/src/platform_impl/windows/monitor.rs b/src/platform_impl/windows/monitor.rs index 7b38fb19..01012b76 100644 --- a/src/platform_impl/windows/monitor.rs +++ b/src/platform_impl/windows/monitor.rs @@ -101,7 +101,7 @@ unsafe extern "system" fn monitor_enum_proc( data: LPARAM, ) -> BOOL { let monitors = data as *mut VecDeque; - (*monitors).push_back(MonitorHandle::new(hmonitor)); + unsafe { (*monitors).push_back(MonitorHandle::new(hmonitor)) }; true.into() // continue enumeration } diff --git a/src/platform_impl/windows/window.rs b/src/platform_impl/windows/window.rs index d90deb76..911cd502 100644 --- a/src/platform_impl/windows/window.rs +++ b/src/platform_impl/windows/window.rs @@ -424,24 +424,26 @@ impl Window { unsafe fn handle_os_dragging(&self, wparam: WPARAM) { let points = { - let mut pos = mem::zeroed(); - GetCursorPos(&mut pos); + let mut pos = unsafe { mem::zeroed() }; + unsafe { GetCursorPos(&mut pos) }; pos }; let points = POINTS { x: points.x as i16, y: points.y as i16, }; - ReleaseCapture(); + unsafe { ReleaseCapture() }; self.window_state_lock().dragging = true; - PostMessageW( - self.hwnd(), - WM_NCLBUTTONDOWN, - wparam, - &points as *const _ as LPARAM, - ); + unsafe { + PostMessageW( + self.hwnd(), + WM_NCLBUTTONDOWN, + wparam, + &points as *const _ as LPARAM, + ) + }; } #[inline] @@ -925,13 +927,13 @@ impl<'a, T: 'static> InitData<'a, T> { unsafe fn create_window(&self, window: HWND) -> Window { // Register for touch events if applicable { - let digitizer = GetSystemMetrics(SM_DIGITIZER) as u32; + let digitizer = unsafe { GetSystemMetrics(SM_DIGITIZER) as u32 }; if digitizer & NID_READY != 0 { - RegisterTouchWindow(window, TWF_WANTPALM); + unsafe { RegisterTouchWindow(window, TWF_WANTPALM) }; } } - let dpi = hwnd_dpi(window); + let dpi = unsafe { hwnd_dpi(window) }; let scale_factor = dpi_to_scale_factor(dpi); // If the system theme is dark, we need to set the window theme now @@ -955,7 +957,7 @@ impl<'a, T: 'static> InitData<'a, T> { enable_non_client_dpi_scaling(window); - ImeContext::set_ime_allowed(window, false); + unsafe { ImeContext::set_ime_allowed(window, false) }; Window { window: WindowWrapper(window), @@ -966,7 +968,7 @@ impl<'a, T: 'static> InitData<'a, T> { unsafe fn create_window_data(&self, win: &Window) -> event_loop::WindowData { let file_drop_handler = if self.pl_attribs.drag_and_drop { - let ole_init_result = OleInitialize(ptr::null_mut()); + let ole_init_result = unsafe { OleInitialize(ptr::null_mut()) }; // It is ok if the initialize result is `S_FALSE` because it might happen that // multiple windows are created on the same thread. if ole_init_result == OLE_E_WRONGCOMPOBJ { @@ -990,9 +992,12 @@ impl<'a, T: 'static> InitData<'a, T> { ); let handler_interface_ptr = - &mut (*file_drop_handler.data).interface as *mut _ as *mut c_void; + unsafe { &mut (*file_drop_handler.data).interface as *mut _ as *mut c_void }; - assert_eq!(RegisterDragDrop(win.window.0, handler_interface_ptr), S_OK); + assert_eq!( + unsafe { RegisterDragDrop(win.window.0, handler_interface_ptr) }, + S_OK + ); Some(file_drop_handler) } else { None @@ -1013,8 +1018,8 @@ impl<'a, T: 'static> InitData<'a, T> { pub unsafe fn on_nccreate(&mut self, window: HWND) -> Option { let runner = self.event_loop.runner_shared.clone(); let result = runner.catch_unwind(|| { - let window = self.create_window(window); - let window_data = self.create_window_data(&window); + let window = unsafe { self.create_window(window) }; + let window_data = unsafe { self.create_window_data(&window) }; (window, window_data) }); @@ -1031,7 +1036,7 @@ impl<'a, T: 'static> InitData<'a, T> { // making the window transparent if self.attributes.transparent && !self.pl_attribs.no_redirection_bitmap { // Empty region for the blur effect, so the window is fully transparent - let region = CreateRectRgn(0, 0, -1, -1); + let region = unsafe { CreateRectRgn(0, 0, -1, -1) }; let bb = DWM_BLURBEHIND { dwFlags: DWM_BB_ENABLE | DWM_BB_BLURREGION, @@ -1039,14 +1044,14 @@ impl<'a, T: 'static> InitData<'a, T> { hRgnBlur: region, fTransitionOnMaximized: false.into(), }; - let hr = DwmEnableBlurBehindWindow(win.hwnd(), &bb); + let hr = unsafe { DwmEnableBlurBehindWindow(win.hwnd(), &bb) }; if hr < 0 { warn!( "Setting transparent window is failed. HRESULT Code: 0x{:X}", hr ); } - DeleteObject(region); + unsafe { DeleteObject(region) }; } win.set_skip_taskbar(self.pl_attribs.skip_taskbar); @@ -1067,7 +1072,7 @@ impl<'a, T: 'static> InitData<'a, T> { if attributes.fullscreen.is_some() { win.set_fullscreen(attributes.fullscreen.map(Into::into)); - force_window_active(win.window.0); + unsafe { force_window_active(win.window.0) }; } else { let size = attributes .inner_size @@ -1112,7 +1117,7 @@ where let title = util::encode_wide(&attributes.title); let class_name = util::encode_wide(&pl_attribs.class_name); - register_window_class::(&class_name); + unsafe { register_window_class::(&class_name) }; let mut window_flags = WindowFlags::empty(); window_flags.set(WindowFlags::MARKER_DECORATIONS, attributes.decorations); @@ -1170,20 +1175,22 @@ where }; let (style, ex_style) = window_flags.to_window_styles(); - let handle = CreateWindowExW( - ex_style, - class_name.as_ptr(), - title.as_ptr(), - style, - CW_USEDEFAULT, - CW_USEDEFAULT, - CW_USEDEFAULT, - CW_USEDEFAULT, - parent.unwrap_or(0), - pl_attribs.menu.unwrap_or(0), - util::get_instance_handle(), - &mut initdata as *mut _ as *mut _, - ); + let handle = unsafe { + CreateWindowExW( + ex_style, + class_name.as_ptr(), + title.as_ptr(), + style, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + parent.unwrap_or(0), + pl_attribs.menu.unwrap_or(0), + util::get_instance_handle(), + &mut initdata as *mut _ as *mut _, + ) + }; // If the window creation in `InitData` panicked, then should resume panicking here if let Err(panic_error) = event_loop.runner_shared.take_panic_error() { @@ -1219,7 +1226,7 @@ unsafe fn register_window_class(class_name: &[u16]) { // an error, and because errors here are detected during CreateWindowEx anyway. // Also since there is no weird element in the struct, there is no reason for this // call to fail. - RegisterClassExW(&class); + unsafe { RegisterClassExW(&class) }; } struct ComInitialized(*mut ()); @@ -1260,20 +1267,22 @@ unsafe fn taskbar_mark_fullscreen(handle: HWND, fullscreen: bool) { let mut task_bar_list2 = task_bar_list2_ptr.get(); if task_bar_list2.is_null() { - let hr = CoCreateInstance( - &CLSID_TaskbarList, - ptr::null_mut(), - CLSCTX_ALL, - &IID_ITaskbarList2, - &mut task_bar_list2 as *mut _ as *mut _, - ); + let hr = unsafe { + CoCreateInstance( + &CLSID_TaskbarList, + ptr::null_mut(), + CLSCTX_ALL, + &IID_ITaskbarList2, + &mut task_bar_list2 as *mut _ as *mut _, + ) + }; if hr != S_OK { // In visual studio retrieving the taskbar list fails return; } - let hr_init = (*(*task_bar_list2).lpVtbl).parent.HrInit; - if hr_init(task_bar_list2.cast()) != S_OK { + let hr_init = unsafe { (*(*task_bar_list2).lpVtbl).parent.HrInit }; + if unsafe { hr_init(task_bar_list2.cast()) } != S_OK { // In some old windows, the taskbar object could not be created, we just ignore it return; } @@ -1281,8 +1290,8 @@ unsafe fn taskbar_mark_fullscreen(handle: HWND, fullscreen: bool) { } task_bar_list2 = task_bar_list2_ptr.get(); - let mark_fullscreen_window = (*(*task_bar_list2).lpVtbl).MarkFullscreenWindow; - mark_fullscreen_window(task_bar_list2, handle, fullscreen.into()); + let mark_fullscreen_window = unsafe { (*(*task_bar_list2).lpVtbl).MarkFullscreenWindow }; + unsafe { mark_fullscreen_window(task_bar_list2, handle, fullscreen.into()) }; }) } @@ -1292,20 +1301,22 @@ pub(crate) unsafe fn set_skip_taskbar(hwnd: HWND, skip: bool) { let mut task_bar_list = task_bar_list_ptr.get(); if task_bar_list.is_null() { - let hr = CoCreateInstance( - &CLSID_TaskbarList, - ptr::null_mut(), - CLSCTX_ALL, - &IID_ITaskbarList, - &mut task_bar_list as *mut _ as *mut _, - ); + let hr = unsafe { + CoCreateInstance( + &CLSID_TaskbarList, + ptr::null_mut(), + CLSCTX_ALL, + &IID_ITaskbarList, + &mut task_bar_list as *mut _ as *mut _, + ) + }; if hr != S_OK { // In visual studio retrieving the taskbar list fails return; } - let hr_init = (*(*task_bar_list).lpVtbl).HrInit; - if hr_init(task_bar_list.cast()) != S_OK { + let hr_init = unsafe { (*(*task_bar_list).lpVtbl).HrInit }; + if unsafe { hr_init(task_bar_list.cast()) } != S_OK { // In some old windows, the taskbar object could not be created, we just ignore it return; } @@ -1314,11 +1325,11 @@ pub(crate) unsafe fn set_skip_taskbar(hwnd: HWND, skip: bool) { task_bar_list = task_bar_list_ptr.get(); if skip { - let delete_tab = (*(*task_bar_list).lpVtbl).DeleteTab; - delete_tab(task_bar_list, hwnd); + let delete_tab = unsafe { (*(*task_bar_list).lpVtbl).DeleteTab }; + unsafe { delete_tab(task_bar_list, hwnd) }; } else { - let add_tab = (*(*task_bar_list).lpVtbl).AddTab; - add_tab(task_bar_list, hwnd); + let add_tab = unsafe { (*(*task_bar_list).lpVtbl).AddTab }; + unsafe { add_tab(task_bar_list, hwnd) }; } }); } @@ -1328,7 +1339,7 @@ unsafe fn force_window_active(handle: HWND) { // This is a little hack which can "steal" the foreground window permission // We only call this function in the window creation, so it should be fine. // See : https://stackoverflow.com/questions/10740346/setforegroundwindow-only-working-while-visual-studio-is-open - let alt_sc = MapVirtualKeyW(VK_MENU as u32, MAPVK_VK_TO_VSC); + let alt_sc = unsafe { MapVirtualKeyW(VK_MENU as u32, MAPVK_VK_TO_VSC) }; let inputs = [ INPUT { @@ -1358,11 +1369,13 @@ unsafe fn force_window_active(handle: HWND) { ]; // Simulate a key press and release - SendInput( - inputs.len() as u32, - inputs.as_ptr(), - mem::size_of::() as i32, - ); + unsafe { + SendInput( + inputs.len() as u32, + inputs.as_ptr(), + mem::size_of::() as i32, + ) + }; - SetForegroundWindow(handle); + unsafe { SetForegroundWindow(handle) }; }