Rework Drag-And-Drop API (#4079)

* Add cursor position drag and drop events.
* Reword drag events to match pointer ones.
* appkit: Use `convertPoint_fromView` for coordinate conversion.
* appkit: use ProtocolObject<dyn NSDraggingInfo>.
* x11: store dnd.position as pair of i16

  It's what translate_coords takes anyway, so the extra precision is
  misleading if we're going to cast it to i16 everywhere it's used.

  We can also simplify the "unpacking" from the XdndPosition message--we
  can and should use the value of 16 as the shift instead of
  size_of::<c_short> * 2 or something like that, because the specification
  gives us the constant 16.
* x11: store translated DnD coords.
* x11: don't emit DragLeave without DragEnter.
* windows: only emit DragEnter if valid.
* windows: in DnD, always set pdwEffect.

  It appears other apps (like Chromium) set pdwEffect on Drop too:
  https://github.com/chromium/chromium/blob/61a391b86bd946d6e1105412539e77ba9fb2a6b3/ui/base/dragdrop/drop_target_win.cc
* docs: make it clearer that drag events are for dragged *files*.
* examples/dnd: handle RedrawRequested event.

Co-authored-by: amrbashir <[email protected]>

examples/dnd.rs

@@ -0,0 +1,64 @@
+use std::error::Error;
+
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::window::{Window, WindowAttributes, WindowId};
+
+#[path = "util/fill.rs"]
+mod fill;
+#[path = "util/tracing.rs"]
+mod tracing;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    tracing::init();
+
+    let event_loop = EventLoop::new()?;
+
+    let app = Application::new();
+    Ok(event_loop.run_app(app)?)
+}
+
+/// Application state and event handling.
+struct Application {
+    window: Option<Box<dyn Window>>,
+}
+
+impl Application {
+    fn new() -> Self {
+        Self { window: None }
+    }
+}
+
+impl ApplicationHandler for Application {
+    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+        let window_attributes =
+            WindowAttributes::default().with_title("Drag and drop files on me!");
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &dyn ActiveEventLoop,
+        _window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        match event {
+            WindowEvent::DragLeft { .. }
+            | WindowEvent::DragEntered { .. }
+            | WindowEvent::DragMoved { .. }
+            | WindowEvent::DragDropped { .. } => {
+                println!("{:?}", event);
+            },
+            WindowEvent::RedrawRequested => {
+                let window = self.window.as_ref().unwrap();
+                window.pre_present_notify();
+                fill::fill_window(window.as_ref());
+            },
+            WindowEvent::CloseRequested => {
+                event_loop.exit();
+            },
+            _ => {},
+        }
+    }
+}

examples/window.rs

@@ -541,11 +541,12 @@ impl ApplicationHandler for Application {
                 info!("Smart zoom");
             },
             WindowEvent::TouchpadPressure { .. }
-            | WindowEvent::HoveredFileCancelled
+            | WindowEvent::DragLeft { .. }
             | WindowEvent::KeyboardInput { .. }
             | WindowEvent::PointerEntered { .. }
-            | WindowEvent::DroppedFile(_)
-            | WindowEvent::HoveredFile(_)
+            | WindowEvent::DragEntered { .. }
+            | WindowEvent::DragMoved { .. }
+            | WindowEvent::DragDropped { .. }
             | WindowEvent::Destroyed
             | WindowEvent::Moved(_) => (),
         }

src/changelog/unreleased.md

@@ -165,6 +165,25 @@ changelog entry.
 - Rename `VideoModeHandle` to `VideoMode`, now it only stores plain data.
 - Make `Fullscreen::Exclusive` contain `(MonitorHandle, VideoMode)`.
 - On Wayland, no longer send an explicit clearing `Ime::Preedit` just prior to a new `Ime::Preedit`.
+- Reworked the file drag-and-drop API.
+
+  The `WindowEvent::DroppedFile`, `WindowEvent::HoveredFile` and `WindowEvent::HoveredFileCancelled`
+  events have been removed, and replaced with `WindowEvent::DragEntered`, `WindowEvent::DragMoved`,
+  `WindowEvent::DragDropped` and `WindowEvent::DragLeft`.
+
+  The old drag-and-drop events were emitted once per file. This occurred when files were *first*
+  hovered over the window, dropped, or left the window. The new drag-and-drop events are emitted
+  once per set of files dragged, and include a list of all dragged files. They also include the
+  pointer position.
+
+  The rough correspondence is:
+  - `WindowEvent::HoveredFile` -> `WindowEvent::DragEntered`
+  - `WindowEvent::DroppedFile` -> `WindowEvent::DragDropped`
+  - `WindowEvent::HoveredFileCancelled` -> `WindowEvent::DragLeft`
+
+  The `WindowEvent::DragMoved` event is entirely new, and is emitted whenever the pointer moves
+  whilst files are being dragged over the window. It doesn't contain any file paths, just the
+  pointer position.
 
 ### Removed
 

src/event.rs

@@ -175,28 +175,42 @@ pub enum WindowEvent {
     /// The window has been destroyed.
     Destroyed,
 
-    /// A file is being hovered over the window.
-    ///
-    /// When the user hovers multiple files at once, this event will be emitted for each file
-    /// separately.
-    HoveredFile(PathBuf),
-
-    /// A file has been dropped into the window.
-    ///
-    /// When the user drops multiple files at once, this event will be emitted for each file
-    /// separately.
-    ///
-    /// The support for this is known to be incomplete, see [#720] for more
-    /// information.
-    ///
-    /// [#720]: https://github.com/rust-windowing/winit/issues/720
-    DroppedFile(PathBuf),
-
-    /// A file was hovered, but has exited the window.
-    ///
-    /// There will be a single `HoveredFileCancelled` event triggered even if multiple files were
-    /// hovered.
-    HoveredFileCancelled,
+    /// A file drag operation has entered the window.
+    DragEntered {
+        /// List of paths that are being dragged onto the window.
+        paths: Vec<PathBuf>,
+        /// (x,y) coordinates in pixels relative to the top-left corner of the window. May be
+        /// negative on some platforms if something is dragged over a window's decorations (title
+        /// bar, frame, etc).
+        position: PhysicalPosition<f64>,
+    },
+    /// A file drag operation has moved over the window.
+    DragMoved {
+        /// (x,y) coordinates in pixels relative to the top-left corner of the window. May be
+        /// negative on some platforms if something is dragged over a window's decorations (title
+        /// bar, frame, etc).
+        position: PhysicalPosition<f64>,
+    },
+    /// The file drag operation has dropped file(s) on the window.
+    DragDropped {
+        /// List of paths that are being dragged onto the window.
+        paths: Vec<PathBuf>,
+        /// (x,y) coordinates in pixels relative to the top-left corner of the window. May be
+        /// negative on some platforms if something is dragged over a window's decorations (title
+        /// bar, frame, etc).
+        position: PhysicalPosition<f64>,
+    },
+    /// The file drag operation has been cancelled or left the window.
+    DragLeft {
+        /// (x,y) coordinates in pixels relative to the top-left corner of the window. May be
+        /// negative on some platforms if something is dragged over a window's decorations (title
+        /// bar, frame, etc).
+        ///
+        /// ## Platform-specific
+        ///
+        /// - **Windows:** Always emits [`None`].
+        position: Option<PhysicalPosition<f64>>,
+    },
 
     /// The window gained or lost focus.
     ///
@@ -1221,9 +1235,16 @@ mod tests {
                 with_window_event(Focused(true));
                 with_window_event(Moved((0, 0).into()));
                 with_window_event(SurfaceResized((0, 0).into()));
-                with_window_event(DroppedFile("x.txt".into()));
-                with_window_event(HoveredFile("x.txt".into()));
-                with_window_event(HoveredFileCancelled);
+                with_window_event(DragEntered {
+                    paths: vec!["x.txt".into()],
+                    position: (0, 0).into(),
+                });
+                with_window_event(DragMoved { position: (0, 0).into() });
+                with_window_event(DragDropped {
+                    paths: vec!["x.txt".into()],
+                    position: (0, 0).into(),
+                });
+                with_window_event(DragLeft { position: Some((0, 0).into()) });
                 with_window_event(Ime(Enabled));
                 with_window_event(PointerMoved {
                     device_id: None,

src/platform_impl/apple/appkit/window_delegate.rs

@@ -13,7 +13,7 @@ use objc2::{declare_class, msg_send_id, mutability, sel, ClassType, DeclaredClas
 use objc2_app_kit::{
     NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
     NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
-    NSColor, NSDraggingDestination, NSFilenamesPboardType, NSPasteboard,
+    NSColor, NSDraggingDestination, NSDraggingInfo, NSFilenamesPboardType,
     NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSViewFrameDidChangeNotification,
     NSWindow, NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
     NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
@@ -375,19 +375,45 @@ declare_class!(
     unsafe impl NSDraggingDestination for WindowDelegate {
         /// Invoked when the dragged image enters destination bounds or frame
         #[method(draggingEntered:)]
-        fn dragging_entered(&self, sender: &NSObject) -> bool {
+        fn dragging_entered(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
             trace_scope!("draggingEntered:");
 
             use std::path::PathBuf;
 
-            let pb: Retained<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
+            let pb = unsafe { sender.draggingPasteboard() };
             let filenames = pb.propertyListForType(unsafe { NSFilenamesPboardType }).unwrap();
             let filenames: Retained<NSArray<NSString>> = unsafe { Retained::cast(filenames) };
+            let paths = filenames
+                .into_iter()
+                .map(|file| PathBuf::from(file.to_string()))
+                .collect();
 
-            filenames.into_iter().for_each(|file| {
-                let path = PathBuf::from(file.to_string());
-                self.queue_event(WindowEvent::HoveredFile(path));
-            });
+            let dl = unsafe { sender.draggingLocation() };
+            let dl = self.view().convertPoint_fromView(dl, None);
+            let position = LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
+
+
+            self.queue_event(WindowEvent::DragEntered { paths, position });
+
+            true
+        }
+
+        #[method(wantsPeriodicDraggingUpdates)]
+        fn wants_periodic_dragging_updates(&self) -> bool {
+            trace_scope!("wantsPeriodicDraggingUpdates:");
+            true
+        }
+
+        /// Invoked periodically as the image is held within the destination area, allowing modification of the dragging operation or mouse-pointer position.
+        #[method(draggingUpdated:)]
+        fn dragging_updated(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
+            trace_scope!("draggingUpdated:");
+
+            let dl = unsafe { sender.draggingLocation() };
+            let dl = self.view().convertPoint_fromView(dl, None);
+            let position = LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
+
+            self.queue_event(WindowEvent::DragMoved { position });
 
             true
         }
@@ -401,19 +427,24 @@ declare_class!(
 
         /// Invoked after the released image has been removed from the screen
         #[method(performDragOperation:)]
-        fn perform_drag_operation(&self, sender: &NSObject) -> bool {
+        fn perform_drag_operation(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
             trace_scope!("performDragOperation:");
 
             use std::path::PathBuf;
 
-            let pb: Retained<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
+            let pb = unsafe { sender.draggingPasteboard() };
             let filenames = pb.propertyListForType(unsafe { NSFilenamesPboardType }).unwrap();
             let filenames: Retained<NSArray<NSString>> = unsafe { Retained::cast(filenames) };
+            let paths = filenames
+                .into_iter()
+                .map(|file| PathBuf::from(file.to_string()))
+                .collect();
 
-            filenames.into_iter().for_each(|file| {
-                let path = PathBuf::from(file.to_string());
-                self.queue_event(WindowEvent::DroppedFile(path));
-            });
+            let dl = unsafe { sender.draggingLocation() };
+            let dl = self.view().convertPoint_fromView(dl, None);
+            let position = LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
+
+            self.queue_event(WindowEvent::DragDropped { paths, position });
 
             true
         }
@@ -426,9 +457,16 @@ declare_class!(
 
         /// Invoked when the dragging operation is cancelled
         #[method(draggingExited:)]
-        fn dragging_exited(&self, _sender: Option<&NSObject>) {
+        fn dragging_exited(&self, info: Option<&ProtocolObject<dyn NSDraggingInfo>>) {
             trace_scope!("draggingExited:");
-            self.queue_event(WindowEvent::HoveredFileCancelled);
+
+            let position = info.map(|info| {
+                let dl = unsafe { info.draggingLocation() };
+                let dl = self.view().convertPoint_fromView(dl, None);
+                LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor())
+            });
+
+            self.queue_event(WindowEvent::DragLeft { position } );
         }
     }
 

src/platform_impl/linux/x11/dnd.rs

@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};
 use std::str::Utf8Error;
 use std::sync::Arc;
 
+use dpi::PhysicalPosition;
 use percent_encoding::percent_decode;
 use x11rb::protocol::xproto::{self, ConnectionExt};
 
@@ -45,20 +46,33 @@ pub struct Dnd {
     pub type_list: Option<Vec<xproto::Atom>>,
     // Populated by XdndPosition event handler
     pub source_window: Option<xproto::Window>,
+    // Populated by XdndPosition event handler
+    pub position: PhysicalPosition<f64>,
     // Populated by SelectionNotify event handler (triggered by XdndPosition event handler)
     pub result: Option<Result<Vec<PathBuf>, DndDataParseError>>,
+    // Populated by SelectionNotify event handler (triggered by XdndPosition event handler)
+    pub dragging: bool,
 }
 
 impl Dnd {
     pub fn new(xconn: Arc<XConnection>) -> Result<Self, X11Error> {
-        Ok(Dnd { xconn, version: None, type_list: None, source_window: None, result: None })
+        Ok(Dnd {
+            xconn,
+            version: None,
+            type_list: None,
+            source_window: None,
+            position: PhysicalPosition::default(),
+            result: None,
+            dragging: false,
+        })
     }
 
     pub fn reset(&mut self) {
         self.version = None;
         self.type_list = None;
         self.source_window = None;
         self.result = None;
+        self.dragging = false;
     }
 
     pub unsafe fn send_status(