Merge branch 'composition-event' into pr/2147

Author: ArturKovacs

CHANGELOG.md

@@ -8,6 +8,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 
 # Unreleased
 
+- macOS: Remove the need to call `set_ime_position` after moving the window.
 - Added `Window::is_visible`.
 - Added `Window::is_resizable`.
 - Added `Window::is_decorated`.
@@ -21,7 +22,10 @@ And please only add new entries to the top of this list, right below the `# Unre
 - **Breaking:** Replaced `EventLoopExtMacOS` with `EventLoopBuilderExtMacOS` (which also has renamed methods).
 - **Breaking:** Replaced `EventLoopExtWindows` with `EventLoopBuilderExtWindows` (which also has renamed methods).
 - **Breaking:** Replaced `EventLoopExtUnix` with `EventLoopBuilderExtUnix` (which also has renamed methods).
+- **Breaking:** The platform specific extensions for Windows `winit::platform::windows` have changed. All `HANDLE`-like types e.g. `HWND` and `HMENU` were converted from winapi types or `*mut c_void` to `isize`. This was done to be consistent with the type definitions in windows-sys and to not expose internal dependencies.
+- The internal bindings to the [Windows API](https://docs.microsoft.com/en-us/windows/) were changed from the unofficial [winapi](https://github.com/retep998/winapi-rs) bindings to the official Microsoft [windows-sys](https://github.com/microsoft/windows-rs) bindings.
 - On Wayland, fix resize and scale factor changes not being propagated properly.
+- On Wayland, fix polling during consecutive `EventLoop::run_return` invocations.
 
 # 0.26.1 (2022-01-05)
 
@@ -30,6 +34,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 - On X11, add mappings for numpad comma, numpad enter, numlock and pause.
 - On macOS, fix Pinyin IME input by reverting a change that intended to improve IME.
 - On Windows, fix a crash with transparent windows on Windows 11.
+- **Breaking:**: Reverse horizontal scrolling sign in `MouseScrollDelta` to match the direction of vertical scrolling. A positive X value now means moving the content to the right. The meaning of vertical scrolling stays the same: a positive Y value means moving the content down.
 
 # 0.26.0 (2021-12-01)
 

Cargo.toml

@@ -55,33 +55,35 @@ default_features = false
 features = ["display_link"]
 
 [target.'cfg(target_os = "windows")'.dependencies]
-parking_lot = "0.11"
+parking_lot = "0.12"
 
-[target.'cfg(target_os = "windows")'.dependencies.winapi]
-version = "0.3.9"
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.33"
 features = [
-    "combaseapi",
-    "commctrl",
-    "dwmapi",
-    "errhandlingapi",
-    "imm",
-    "hidusage",
-    "libloaderapi",
-    "objbase",
-    "ole2",
-    "processthreadsapi",
-    "shellapi",
-    "shellscalingapi",
-    "shobjidl_core",
-    "unknwnbase",
-    "winbase",
-    "windowsx",
-    "winerror",
-    "wingdi",
-    "winnt",
-    "winuser",
-    "mmsystem",
-    "timeapi"
+    "Win32_Devices_HumanInterfaceDevice",
+    "Win32_Foundation",
+    "Win32_Globalization",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_Media",
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_Com",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Ole",
+    "Win32_System_SystemInformation",
+    "Win32_System_SystemServices",
+    "Win32_System_Threading",
+    "Win32_System_WindowsProgramming",
+    "Win32_UI_Accessibility",
+    "Win32_UI_Controls",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_Ime",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Input_Pointer",
+    "Win32_UI_Input_Touch",
+    "Win32_UI_Shell",
+    "Win32_UI_TextServices",
+    "Win32_UI_WindowsAndMessaging",
 ]
 
 [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
@@ -91,7 +93,7 @@ sctk = { package = "smithay-client-toolkit", version = "0.15.1", default_feature
 mio = { version = "0.8", features = ["os-ext"], optional = true }
 x11-dl = { version = "2.18.5", optional = true }
 percent-encoding = { version = "2.0", optional = true }
-parking_lot = { version = "0.11.0", optional = true }
+parking_lot = { version = "0.12.0", optional = true }
 libc = "0.2.64"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.web_sys]

examples/mouse_wheel.rs

@@ -1,6 +1,6 @@
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{DeviceEvent, Event, WindowEvent},
+    event::{Event, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder,
 };
@@ -14,29 +14,41 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
+    println!(
+        r"
+When using so called 'natural scrolling' (scrolling that acts like on a touch screen), this is what to expect:
+
+Moving your finger downwards on a scroll wheel should make the window move down, and you should see a positive Y scroll value.
+
+When moving fingers on a trackpad down and to the right, you should see positive X and Y deltas, and the window should move down and to the right.
+
+With reverse scrolling, you should see the inverse behavior.
+
+In both cases the example window should move like the content of a scroll area in any other application.
+
+In other words, the deltas indicate the direction in which to move the content (in this case the window)."
+    );
+
     event_loop.run(move |event, _, control_flow| {
         *control_flow = ControlFlow::Wait;
 
         match event {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                _ => (),
-            },
-            Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseWheel { delta } => match delta {
+                WindowEvent::MouseWheel { delta, .. } => match delta {
                     winit::event::MouseScrollDelta::LineDelta(x, y) => {
                         println!("mouse wheel Line Delta: ({},{})", x, y);
                         let pixels_per_line = 120.0;
                         let mut pos = window.outer_position().unwrap();
-                        pos.x -= (x * pixels_per_line) as i32;
-                        pos.y -= (y * pixels_per_line) as i32;
+                        pos.x += (x * pixels_per_line) as i32;
+                        pos.y += (y * pixels_per_line) as i32;
                         window.set_outer_position(pos)
                     }
                     winit::event::MouseScrollDelta::PixelDelta(p) => {
                         println!("mouse wheel Pixel Delta: ({},{})", p.x, p.y);
                         let mut pos = window.outer_position().unwrap();
-                        pos.x -= p.x as i32;
-                        pos.y -= p.y as i32;
+                        pos.x += p.x as i32;
+                        pos.y += p.y as i32;
                         window.set_outer_position(pos)
                     }
                 },

src/event.rs

@@ -785,15 +785,23 @@ pub enum MouseScrollDelta {
     /// Amount in lines or rows to scroll in the horizontal
     /// and vertical directions.
     ///
-    /// Positive values indicate movement forward
-    /// (away from the user) or rightwards.
+    /// Positive values indicate that the content that is being scrolled should move
+    /// right and down (revealing more content left and up).
     LineDelta(f32, f32),
+
     /// Amount in pixels to scroll in the horizontal and
     /// vertical direction.
     ///
     /// Scroll events are expressed as a PixelDelta if
     /// supported by the device (eg. a touchpad) and
     /// platform.
+    ///
+    /// Positive values indicate that the content being scrolled should
+    /// move right/down.
+    ///
+    /// For a 'natural scrolling' touch pad (that acts like a touch screen)
+    /// this means moving your fingers right and down should give positive values,
+    /// and move the content right and down (to reveal more things left and up).
     PixelDelta(PhysicalPosition<f64>),
 }
 

src/platform/windows.rs

@@ -1,11 +1,7 @@
 #![cfg(target_os = "windows")]
 
-use std::os::raw::c_void;
 use std::path::Path;
 
-use winapi::shared::minwindef::WORD;
-use winapi::shared::windef::{HMENU, HWND};
-
 use crate::{
     dpi::PhysicalSize,
     event::DeviceId,
@@ -15,6 +11,15 @@ use crate::{
     window::{BadIcon, Icon, Theme, Window, WindowBuilder},
 };
 
+/// Window Handle type used by Win32 API
+pub type HWND = isize;
+/// Menu Handle type used by Win32 API
+pub type HMENU = isize;
+/// Monitor Handle type used by Win32 API
+pub type HMONITOR = isize;
+/// Instance Handle type used by Win32 API
+pub type HINSTANCE = isize;
+
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopBuilderExtWindows {
     /// Whether to allow the event loop to be created off of the main thread.
@@ -70,11 +75,11 @@ impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
     /// Returns the HINSTANCE of the window
-    fn hinstance(&self) -> *mut c_void;
+    fn hinstance(&self) -> HINSTANCE;
     /// Returns the native handle that is used by this window.
     ///
     /// The pointer will become invalid when the native window was destroyed.
-    fn hwnd(&self) -> *mut c_void;
+    fn hwnd(&self) -> HWND;
 
     /// Enables or disables mouse and keyboard input to the specified window.
     ///
@@ -100,13 +105,13 @@ pub trait WindowExtWindows {
 
 impl WindowExtWindows for Window {
     #[inline]
-    fn hinstance(&self) -> *mut c_void {
-        self.window.hinstance() as *mut _
+    fn hinstance(&self) -> HINSTANCE {
+        self.window.hinstance()
     }
 
     #[inline]
-    fn hwnd(&self) -> *mut c_void {
-        self.window.hwnd() as *mut _
+    fn hwnd(&self) -> HWND {
+        self.window.hwnd()
     }
 
     #[inline]
@@ -150,10 +155,12 @@ 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 [`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.
+    ///
+    /// [`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu
     fn with_menu(self, menu: HMENU) -> WindowBuilder;
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
@@ -224,7 +231,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 {
@@ -234,8 +241,8 @@ impl MonitorHandleExtWindows for MonitorHandle {
     }
 
     #[inline]
-    fn hmonitor(&self) -> *mut c_void {
-        self.inner.hmonitor() as *mut _
+    fn hmonitor(&self) -> HMONITOR {
+        self.inner.hmonitor()
     }
 }
 
@@ -273,7 +280,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 {
@@ -285,7 +292,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 })
     }