Replace winapi with windows crate bindings shared with WRY

.changes/webview2-com-sys.md

@@ -0,0 +1,5 @@
+---
+"tao": patch
+---
+
+Replace all of the `winapi` crate references with the `windows` crate. The generated bindings are in the `webview2-com-sys` crate to share types with WRY later.

Cargo.toml

@@ -71,33 +71,8 @@ cc = "1"
 [target."cfg(target_os = \"windows\")".dependencies]
 parking_lot = "0.11"
 unicode-segmentation = "1.8.0"
-
-  [target."cfg(target_os = \"windows\")".dependencies.winapi]
-  version = "0.3"
-  features = [
-  "combaseapi",
-  "commctrl",
-  "dwmapi",
-  "errhandlingapi",
-  "imm",
-  "hidusage",
-  "libloaderapi",
-  "objbase",
-  "ole2",
-  "processthreadsapi",
-  "shellapi",
-  "shellscalingapi",
-  "shobjidl_core",
-  "unknwnbase",
-  "winbase",
-  "windowsx",
-  "winerror",
-  "wingdi",
-  "winnt",
-  "winnls",
-  "winuser",
-  "impl-default"
-]
+webview2-com-sys = "0.4.0"
+windows = "0.19.0"
 
 [target."cfg(any(target_os = \"linux\", target_os = \"dragonfly\", target_os = \"freebsd\", target_os = \"openbsd\", target_os = \"netbsd\"))".dependencies]
 cairo-rs = "0.14"
@@ -108,6 +83,6 @@ gtk = { version = "0.14", features = [ "v3_22" ] }
 gdk = { version = "0.14", features = [ "v3_22" ] }
 gdk-sys = "0.14"
 gdk-pixbuf = { version = "0.14", features = [ "v2_36_8" ] }
-libayatana-appindicator = { version = "0.1.4", optional = true }
+libayatana-appindicator = { version = "0.1.6", optional = true }
 tauri-libappindicator = { version = "0.1.2", optional = true }
 x11-dl = "2.18"

examples/parentwindow.rs

@@ -16,7 +16,7 @@ fn main() {
     window::WindowBuilder,
   };
   #[cfg(target_os = "windows")]
-  use winapi::shared::windef::HWND;
+  use webview2_com_sys::Windows::Win32::Foundation::HWND;
   SimpleLogger::new().init().unwrap();
   let event_loop = EventLoop::new();
   let mut windows = HashMap::new();
@@ -25,7 +25,7 @@ fn main() {
   #[cfg(target_os = "macos")]
   let parent_window = main_window.ns_window();
   #[cfg(target_os = "windows")]
-  let parent_window = main_window.hwnd() as HWND;
+  let parent_window = HWND(main_window.hwnd() as _);
 
   let child_window = WindowBuilder::new()
     .with_parent_window(parent_window)

src/clipboard.rs

@@ -54,6 +54,7 @@ pub(crate) type FormatId = &'static str;
 
 /// Object that allows you to access the `ClipboardFormat`.
 #[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub(crate) struct ClipboardFormat {
   pub(crate) identifier: FormatId,
   pub(crate) data: Vec<u8>,

src/lib.rs

@@ -141,7 +141,7 @@
   clippy::wrong_self_convention
 )]
 #![deny(rust_2018_idioms)]
-#![deny(broken_intra_doc_links)]
+#![deny(rustdoc::broken_intra_doc_links)]
 
 #[allow(unused_imports)]
 #[macro_use]

src/platform/windows.rs

@@ -3,7 +3,7 @@
 
 #![cfg(target_os = "windows")]
 
-use std::{os::raw::c_void, path::Path};
+use std::path::Path;
 
 pub use crate::platform_impl::hit_test;
 use crate::{
@@ -15,12 +15,10 @@ use crate::{
   window::{BadIcon, Icon, Theme, Window, WindowBuilder},
 };
 use libc;
-use winapi::{
-  shared::{
-    minwindef::{self, WORD},
-    windef::{HMENU, HWND, POINT},
-  },
-  um::winuser,
+use webview2_com_sys::Windows::Win32::{
+  Foundation::{HWND, LPARAM, WPARAM},
+  Graphics::Gdi::HMONITOR,
+  UI::{KeyboardAndMouseInput::*, WindowsAndMessaging::*},
 };
 
 /// Additional methods on `EventLoop` that are specific to Windows.
@@ -123,18 +121,18 @@ pub trait WindowExtWindows {
 impl WindowExtWindows for Window {
   #[inline]
   fn hinstance(&self) -> *mut libc::c_void {
-    self.window.hinstance() as *mut _
+    self.window.hinstance().0 as _
   }
 
   #[inline]
   fn hwnd(&self) -> *mut libc::c_void {
-    self.window.hwnd() as *mut _
+    self.window.hwnd().0 as _
   }
 
   #[inline]
   fn set_enable(&self, enabled: bool) {
     unsafe {
-      winapi::um::winuser::EnableWindow(self.hwnd() as _, enabled as _);
+      EnableWindow(self.window.hwnd(), enabled);
     }
   }
 
@@ -156,14 +154,14 @@ impl WindowExtWindows for Window {
   #[inline]
   fn begin_resize_drag(&self, edge: isize, button: u32, x: i32, y: i32) {
     unsafe {
-      let point = POINT { x, y };
-      winuser::ReleaseCapture();
-      winuser::PostMessageW(
-        self.hwnd() as _,
-        button as minwindef::UINT,
-        edge as minwindef::WPARAM,
-        &point as *const _ as minwindef::LPARAM,
-      );
+      let w_param = WPARAM(edge as usize);
+
+      let low_word = x as u32 & 0xFFFF;
+      let high_word = (y as u32 & 0xFFFF) << 16;
+      let l_param = LPARAM((low_word | high_word) as isize);
+
+      ReleaseCapture();
+      PostMessageW(self.window.hwnd(), button, w_param, l_param);
     }
   }
 
@@ -198,7 +196,8 @@ pub trait WindowBuilderExtWindows {
   ///
   /// Parent and menu are mutually exclusive; a child window cannot have a menu!
   ///
-  /// The menu must have been manually created beforehand with [`winapi::um::winuser::CreateMenu`] or similar.
+  /// The menu must have been manually created beforehand with [`webview2_com_sys::Windows::Win32::UI::WindowsAndMessaging::CreateMenu`]
+  /// or similar.
   ///
   /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
   /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
@@ -281,7 +280,7 @@ pub trait MonitorHandleExtWindows {
   fn native_id(&self) -> String;
 
   /// Returns the handle of the monitor - `HMONITOR`.
-  fn hmonitor(&self) -> *mut c_void;
+  fn hmonitor(&self) -> HMONITOR;
 }
 
 impl MonitorHandleExtWindows for MonitorHandle {
@@ -291,8 +290,8 @@ impl MonitorHandleExtWindows for MonitorHandle {
   }
 
   #[inline]
-  fn hmonitor(&self) -> *mut c_void {
-    self.inner.hmonitor() as *mut _
+  fn hmonitor(&self) -> HMONITOR {
+    self.inner.hmonitor()
   }
 }
 
@@ -329,7 +328,7 @@ pub trait IconExtWindows: Sized {
   ///
   /// In cases where the specified size does not exist in the file, Windows may perform scaling
   /// to get an icon of the desired size.
-  fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+  fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
 }
 
 impl IconExtWindows for Icon {
@@ -338,7 +337,7 @@ impl IconExtWindows for Icon {
     Ok(Icon { inner: win_icon })
   }
 
-  fn from_resource(ordinal: WORD, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+  fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
     let win_icon = WinIcon::from_resource(ordinal, size)?;
     Ok(Icon { inner: win_icon })
   }

src/platform_impl/linux/event_loop.rs

@@ -19,7 +19,7 @@ use gtk::{prelude::*, AboutDialog, ApplicationWindow, Inhibit};
 use crate::{
   accelerator::AcceleratorId,
   dpi::{PhysicalPosition, PhysicalSize},
-  event::{DeviceId as RootDeviceId, ElementState, Event, MouseButton, StartCause, WindowEvent},
+  event::{ElementState, Event, MouseButton, StartCause, WindowEvent},
   event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW},
   keyboard::ModifiersState,
   menu::{MenuItem, MenuType},
@@ -32,7 +32,6 @@ use super::{
   keyboard,
   monitor::MonitorHandle,
   window::{WindowId, WindowRequest},
-  DeviceId,
 };
 
 pub struct EventLoopWindowTarget<T> {
@@ -55,7 +54,7 @@ impl<T> EventLoopWindowTarget<T> {
     let numbers = display.n_monitors();
 
     for i in 0..numbers {
-      let monitor = MonitorHandle::new(&display, i);
+      let monitor = MonitorHandle::new(display, i);
       handles.push_back(monitor);
     }
 
@@ -351,19 +350,17 @@ impl<T: 'static> EventLoop<T> {
                 Inhibit(false)
               });
               window.connect_button_press_event(|window, event| {
-                if !window.is_decorated() && window.is_resizable() {
-                  if event.button() == 1 {
-                    if let Some(window) = window.window() {
-                      let (cx, cy) = event.root();
-                      let result = hit_test(&window, cx, cy);
-
-                      // Ignore the `__Unknown` variant so the window receives the click correctly if it is not on the edges.
-                      match result {
-                        WindowEdge::__Unknown(_) => (),
-                        _ => {
-                          // FIXME: calling `window.begin_resize_drag` uses the default cursor, it should show a resizing cursor instead
-                          window.begin_resize_drag(result, 1, cx as i32, cy as i32, event.time())
-                        }
+                if !window.is_decorated() && window.is_resizable() && event.button() == 1 {
+                  if let Some(window) = window.window() {
+                    let (cx, cy) = event.root();
+                    let result = hit_test(&window, cx, cy);
+
+                    // Ignore the `__Unknown` variant so the window receives the click correctly if it is not on the edges.
+                    match result {
+                      WindowEdge::__Unknown(_) => (),
+                      _ => {
+                        // FIXME: calling `window.begin_resize_drag` uses the default cursor, it should show a resizing cursor instead
+                        window.begin_resize_drag(result, 1, cx as i32, cy as i32, event.time())
                       }
                     }
                   }

src/platform_impl/linux/menu.rs

@@ -57,6 +57,7 @@ unsafe impl Send for Menu {}
 unsafe impl Sync for Menu {}
 
 #[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub struct MenuItemAttributes {
   id: MenuId,
   key: Option<Accelerator>,
@@ -113,7 +114,7 @@ impl Menu {
     menu_type: MenuType,
   ) -> CustomMenuItem {
     let gtk_item = if selected {
-      let item = CheckMenuItem::with_label(&title);
+      let item = CheckMenuItem::with_label(title);
       item.set_active(true);
       item.upcast::<GtkMenuItem>()
     } else {

src/platform_impl/linux/mod.rs

@@ -40,19 +40,11 @@ pub struct KeyEventExtra {
   pub key_without_modifiers: Key<'static>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct PlatformSpecificWindowBuilderAttributes {
   pub skip_taskbar: bool,
 }
 
-impl Default for PlatformSpecificWindowBuilderAttributes {
-  fn default() -> Self {
-    Self {
-      skip_taskbar: false,
-    }
-  }
-}
-
 unsafe impl Send for PlatformSpecificWindowBuilderAttributes {}
 unsafe impl Sync for PlatformSpecificWindowBuilderAttributes {}
 

src/platform_impl/macos/monitor.rs

@@ -165,6 +165,7 @@ impl fmt::Debug for MonitorHandle {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     // TODO: Do this using the proper fmt API
     #[derive(Debug)]
+    #[allow(dead_code)] // none of the member reads in Debug::fmt are detected
     struct MonitorHandle {
       name: Option<String>,
       native_identifier: u32,

src/platform_impl/windows/accelerator.rs

@@ -7,19 +7,20 @@ use std::{
 };
 
 use lazy_static::lazy_static;
-use winapi::{ctypes::c_int, shared::windef::*, um::winuser::*};
+
+use webview2_com_sys::Windows::Win32::{Foundation::HWND, UI::WindowsAndMessaging::*};
 
 // NOTE:
 // https://docs.microsoft.com/en-us/windows/win32/wsw/thread-safety
 // All handles you obtain from functions in Kernel32 are thread-safe,
 // unless the MSDN Library article for the function explicitly mentions it is not.
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-struct WindowHandle(HWND);
+struct WindowHandle(isize);
 unsafe impl Send for WindowHandle {}
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-struct AccelHandle(HACCEL);
+struct AccelHandle(isize);
 unsafe impl Send for AccelHandle {}
 unsafe impl Sync for AccelHandle {}
 
@@ -36,32 +37,31 @@ pub(crate) struct AccelTable {
 
 impl AccelTable {
   fn new(accel: &[ACCEL]) -> AccelTable {
-    let accel =
-      unsafe { CreateAcceleratorTableW(accel as *const _ as *mut _, accel.len() as c_int) };
+    let accel = unsafe { CreateAcceleratorTableW(accel as *const _ as *mut _, accel.len() as i32) };
     AccelTable {
-      accel: AccelHandle(accel),
+      accel: AccelHandle(accel.0),
     }
   }
 
   pub(crate) fn handle(&self) -> HACCEL {
-    self.accel.0
+    HACCEL(self.accel.0)
   }
 }
 
 pub(crate) fn register_accel(hwnd: HWND, accel: &[ACCEL]) {
   let mut table = ACCEL_TABLES.lock().unwrap();
-  table.insert(WindowHandle(hwnd), Arc::new(AccelTable::new(accel)));
+  table.insert(WindowHandle(hwnd.0), Arc::new(AccelTable::new(accel)));
 }
 
 impl Drop for AccelTable {
   fn drop(&mut self) {
     unsafe {
-      DestroyAcceleratorTable(self.accel.0);
+      DestroyAcceleratorTable(self.handle());
     }
   }
 }
 
 pub(crate) fn find_accels(hwnd: HWND) -> Option<Arc<AccelTable>> {
   let table = ACCEL_TABLES.lock().unwrap();
-  table.get(&WindowHandle(hwnd)).cloned()
+  table.get(&WindowHandle(hwnd.0)).cloned()
 }