Add dragging window with cursor feature

CHANGELOG.md

@@ -12,6 +12,8 @@
 - On Android, bump `ndk` and `ndk-glue` to 0.3: use predefined constants for event `ident`.
 - On Windows, fixed `WindowEvent::ThemeChanged` not properly firing and fixed `Window::theme` returning the wrong theme.
 - On Web, added support for `DeviceEvent::MouseMotion` to listen for relative mouse movements.
+- Added `Window::set_drag_window`. Implemented on Windows, macOS and X11.
+- Added `Window::begin_drag`. Implemented on Windows, macOS and X11.
 
 # 0.24.0 (2020-12-09)
 

FEATURES.md

@@ -209,6 +209,7 @@ Legend:
 |Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |
 |Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |
 |Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |
+|Drag window with cursor |✔️         |✔️       |✔️        |❌           |**N/A**|**N/A**|**N/A**   |
 
 ### Pending API Reworks
 Changes in the API that have been agreed upon but aren't implemented across all platforms.

examples/drag_window.rs

@@ -0,0 +1,73 @@
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{
+        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+    },
+    event_loop::{ControlFlow, EventLoop},
+    window::{Window, WindowBuilder, WindowId},
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
+    let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
+
+    let mut switched = false;
+    let mut entered_id = window_2.id();
+
+    event_loop.run(move |event, _, control_flow| match event {
+        Event::NewEvents(StartCause::Init) => {
+            eprintln!("Switch which window is to be dragged by pressing \"x\".")
+        }
+        Event::WindowEvent { event, window_id } => match event {
+            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+            WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                ..
+            } => {
+                let window = if (window_id == window_1.id() && switched)
+                    || (window_id == window_2.id() && !switched)
+                {
+                    &window_2
+                } else {
+                    &window_1
+                };
+
+                window.begin_drag().unwrap()
+            }
+            WindowEvent::CursorEntered { .. } => {
+                entered_id = window_id;
+                name_windows(entered_id, switched, &window_1, &window_2)
+            }
+            WindowEvent::KeyboardInput {
+                input:
+                    KeyboardInput {
+                        state: ElementState::Released,
+                        virtual_keycode: Some(VirtualKeyCode::X),
+                        ..
+                    },
+                ..
+            } => {
+                switched = !switched;
+                name_windows(entered_id, switched, &window_1, &window_2);
+                println!("Switched!")
+            }
+            _ => (),
+        },
+        _ => (),
+    });
+}
+
+fn name_windows(window_id: WindowId, switched: bool, window_1: &Window, window_2: &Window) {
+    let (drag_target, other) =
+        if (window_id == window_1.id() && switched) || (window_id == window_2.id() && !switched) {
+            (&window_2, &window_1)
+        } else {
+            (&window_1, &window_2)
+        };
+    drag_target.set_title("drag target");
+    other.set_title("winit window");
+}

src/platform_impl/android/mod.rs

@@ -556,6 +556,12 @@ impl Window {
 
     pub fn set_cursor_visible(&self, _: bool) {}
 
+    pub fn begin_drag(&self) -> Result<(), error::ExternalError> {
+        Err(error::ExternalError::NotSupported(
+            error::NotSupportedError::new(),
+        ))
+    }
+
     pub fn raw_window_handle(&self) -> raw_window_handle::RawWindowHandle {
         let a_native_window = if let Some(native_window) = ndk_glue::native_window().as_ref() {
             unsafe { native_window.ptr().as_mut() as *mut _ as *mut _ }

src/platform_impl/ios/window.rs

@@ -182,6 +182,10 @@ impl Inner {
         debug!("`Window::set_cursor_visible` is ignored on iOS")
     }
 
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
     pub fn set_minimized(&self, _minimized: bool) {
         warn!("`Window::set_minimized` is ignored on iOS")
     }

src/platform_impl/linux/mod.rs

@@ -358,6 +358,16 @@ impl Window {
         x11_or_wayland!(match self; Window(window) => window.set_cursor_visible(visible))
     }
 
+    #[inline]
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        match self {
+            #[cfg(feature = "x11")]
+            &Window::X(ref w) => w.begin_drag(),
+            #[cfg(feature = "wayland")]
+            _ => Err(ExternalError::NotSupported(NotSupportedError::new())),
+        }
+    }
+
     #[inline]
     pub fn scale_factor(&self) -> f64 {
         x11_or_wayland!(match self; Window(w) => w.scale_factor() as f64)

src/platform_impl/linux/x11/window.rs

@@ -1276,6 +1276,46 @@ impl UnownedWindow {
         self.set_cursor_position_physical(x, y)
     }
 
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        let pointer = self
+            .xconn
+            .query_pointer(self.xwindow, util::VIRTUAL_CORE_POINTER)
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))?;
+
+        let window = self.inner_position().map_err(ExternalError::NotSupported)?;
+
+        let message = unsafe { self.xconn.get_atom_unchecked(b"_NET_WM_MOVERESIZE\0") };
+
+        // we can't use `set_cursor_grab(false)` here because it doesn't run `XUngrabPointer`
+        // if the cursor isn't currently grabbed
+        let mut grabbed_lock = self.cursor_grabbed.lock();
+        unsafe {
+            (self.xconn.xlib.XUngrabPointer)(self.xconn.display, ffi::CurrentTime);
+        }
+        self.xconn
+            .flush_requests()
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))?;
+        *grabbed_lock = false;
+
+        // we keep the lock until we are done
+        self.xconn
+            .send_client_msg(
+                self.xwindow,
+                self.root,
+                message,
+                Some(ffi::SubstructureRedirectMask | ffi::SubstructureNotifyMask),
+                [
+                    (window.x as c_long + pointer.win_x as c_long),
+                    (window.y as c_long + pointer.win_y as c_long),
+                    8, // _NET_WM_MOVERESIZE_MOVE
+                    ffi::Button1 as c_long,
+                    1,
+                ],
+            )
+            .flush()
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))
+    }
+
     pub(crate) fn set_ime_position_physical(&self, x: i32, y: i32) {
         let _ = self
             .ime_sender

src/platform_impl/macos/window.rs

@@ -636,6 +636,16 @@ impl UnownedWindow {
         Ok(())
     }
 
+    #[inline]
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        unsafe {
+            let event: id = msg_send![NSApp(), currentEvent];
+            let _: () = msg_send![*self.ns_window, performWindowDragWithEvent: event];
+        }
+
+        Ok(())
+    }
+
     pub(crate) fn is_zoomed(&self) -> bool {
         // because `isZoomed` doesn't work if the window's borderless,
         // we make it resizable temporalily.

src/platform_impl/web/window.rs

@@ -222,6 +222,11 @@ impl Window {
         }
     }
 
+    #[inline]
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
     #[inline]
     pub fn set_minimized(&self, _minimized: bool) {
         // Intentionally a no-op, as canvases cannot be 'minimized'

src/platform_impl/windows/window.rs

@@ -14,8 +14,8 @@ use std::{
 use winapi::{
     ctypes::c_int,
     shared::{
-        minwindef::{HINSTANCE, UINT},
-        windef::{HWND, POINT, RECT},
+        minwindef::{HINSTANCE, LPARAM, UINT, WPARAM},
+        windef::{HWND, POINT, POINTS, RECT},
     },
     um::{
         combaseapi, dwmapi,
@@ -26,7 +26,7 @@ use winapi::{
         oleidl::LPDROPTARGET,
         shobjidl_core::{CLSID_TaskbarList, ITaskbarList2},
         wingdi::{CreateRectRgn, DeleteObject},
-        winnt::LPCWSTR,
+        winnt::{LPCWSTR, SHORT},
         winuser,
     },
 };
@@ -357,6 +357,30 @@ impl Window {
         Ok(())
     }
 
+    #[inline]
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        unsafe {
+            let points = {
+                let mut pos = mem::zeroed();
+                winuser::GetCursorPos(&mut pos);
+                pos
+            };
+            let points = POINTS {
+                x: points.x as SHORT,
+                y: points.y as SHORT,
+            };
+            winuser::ReleaseCapture();
+            winuser::PostMessageW(
+                self.window.0,
+                winuser::WM_NCLBUTTONDOWN,
+                winuser::HTCAPTION as WPARAM,
+                &points as *const _ as LPARAM,
+            );
+        }
+
+        Ok(())
+    }
+
     #[inline]
     pub fn id(&self) -> WindowId {
         WindowId(self.window.0)

src/window.rs

@@ -764,6 +764,21 @@ impl Window {
     pub fn set_cursor_visible(&self, visible: bool) {
         self.window.set_cursor_visible(visible)
     }
+
+    /// Moves the window with the left mouse button until the button is released.
+    ///
+    /// There's no guarantee that this will work unless the left mouse button was pressed
+    /// immediately before this function is called.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11:** Un-grabs the cursor.
+    /// - **macOS:** May prevent the button release event to be triggered.
+    /// - **Wayland / iOS / Android / Web:** Always returns an [`ExternalError::NotSupported`].
+    #[inline]
+    pub fn begin_drag(&self) -> Result<(), ExternalError> {
+        self.window.begin_drag()
+    }
 }
 
 /// Monitor info functions.