Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Add macOS file drag-out from project panel (#58161)
Lee ByeongJunf52fd9ac44b2
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rsindex 18b64ad9658..1a7877d3778 100644--- a/crates/gpui/src/app.rs+++ b/crates/gpui/src/app.rs@@ -45,14 +45,15 @@ use crate::InspectorElementRegistry;use crate::{Action, ActionBuildError, ActionRegistry, Any, AnyView, AnyWindowHandle, AppContext, Arena,ArenaBox, Asset, AssetSource, BackgroundExecutor, Bounds, ClipboardItem, CursorStyle,- DispatchPhase, DisplayId, EventEmitter, FocusHandle, FocusMap, ForegroundExecutor, Global,- KeyBinding, KeyContext, Keymap, Keystroke, LayoutId, Menu, MenuItem, OwnedMenu,- PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformKeyboardLayout,- PlatformKeyboardMapper, Point, Priority, PromptBuilder, PromptButton, PromptHandle,- PromptLevel, Render, RenderImage, RenderablePromptHandle, Reservation, ScreenCaptureSource,- SharedString, SubscriberSet, Subscription, SvgRenderer, SystemNotification,- SystemNotificationResponse, Task, TextRenderingMode, TextSystem, ThermalState, Window,- WindowAppearance, WindowButtonLayout, WindowHandle, WindowId, WindowInvalidator,+ DispatchPhase, DisplayId, EventEmitter, ExternalDragPayload, FocusHandle, FocusMap,+ ForegroundExecutor, Global, KeyBinding, KeyContext, Keymap, Keystroke, LayoutId, Menu,+ MenuItem, OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay,+ PlatformKeyboardLayout, PlatformKeyboardMapper, Point, Priority, PromptBuilder, PromptButton,+ PromptHandle, PromptLevel, Render, RenderImage, RenderablePromptHandle, Reservation,+ ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer,+ SystemNotification, SystemNotificationResponse, Task, TextRenderingMode, TextSystem,+ ThermalState, Window, WindowAppearance, WindowButtonLayout, WindowHandle, WindowId,+ WindowInvalidator,colors::{Colors, GlobalColors},hash, init_app_menus,};@@ -2814,8 +2815,17 @@ pub struct AnyDrag {/// The cursor style to use while draggingpub cursor_style: Option<CursorStyle>,++ /// Resolves the payload to offer the platform if the drag leaves the window.+ /// Invoked at most once per drag gesture, at promotion time.+ pub external_payload_source: Option<ExternalDragPayloadSource>,}+/// Lazily resolves the payload handed to the platform when an internal drag is+/// promoted to a native drag session.+pub type ExternalDragPayloadSource =+ Box<dyn FnOnce(&mut Window, &mut App) -> Option<ExternalDragPayload> + 'static>;+/// Contains state associated with a tooltip. You'll only need this struct if you're implementing/// tooltip behavior on a custom element. Otherwise, use [Div::tooltip](crate::Interactivity::tooltip).#[derive(Clone)]diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rsindex 383d380636d..0c435543f5a 100644--- a/crates/gpui/src/elements/div.rs+++ b/crates/gpui/src/elements/div.rs@@ -18,13 +18,13 @@use crate::PinchEvent;use crate::{Action, AnyDrag, AnyElement, AnyTooltip, AnyView, App, Bounds, ClickEvent, DispatchPhase,- Display, Element, ElementId, Entity, EntityId, FocusHandle, Global, GlobalElementId, Hitbox,- HitboxBehavior, HitboxId, InspectorElementId, IntoElement, IsZero, KeyContext, KeyDownEvent,- KeyUpEvent, KeyboardButton, KeyboardClickEvent, LayoutId, ModifiersChangedEvent, MouseButton,- MouseClickEvent, MouseDownEvent, MouseExitEvent, MouseMoveEvent, MousePressureEvent,- MouseUpEvent, Overflow, ParentElement, Pixels, Point, Render, ScrollWheelEvent, SharedString,- Size, Style, StyleRefinement, Styled, Task, TooltipId, Visibility, Window, WindowControlArea,- point, px, size,+ Display, Element, ElementId, Entity, EntityId, ExternalDragPayload, ExternalDragPayloadSource,+ FocusHandle, Global, GlobalElementId, Hitbox, HitboxBehavior, HitboxId, InspectorElementId,+ IntoElement, IsZero, KeyContext, KeyDownEvent, KeyUpEvent, KeyboardButton, KeyboardClickEvent,+ LayoutId, ModifiersChangedEvent, MouseButton, MouseClickEvent, MouseDownEvent, MouseExitEvent,+ MouseMoveEvent, MousePressureEvent, MouseUpEvent, Overflow, ParentElement, Pixels, Point,+ Render, ScrollWheelEvent, SharedString, Size, Style, StyleRefinement, Styled, Task, TooltipId,+ Visibility, Window, WindowControlArea, point, px, size,};use collections::HashMap;use gpui_util::ResultExt;@@ -605,12 +605,41 @@ impl Interactivity {self.drag_listener.is_none(),"calling on_drag more than once on the same element is not supported");- self.drag_listener = Some((- Arc::new(value),- Box::new(move |value, offset, window, cx| {+ self.drag_listener = Some(DragListener {+ value: Arc::new(value),+ render: Box::new(move |value, offset, window, cx| {constructor(value.downcast_ref().unwrap(), offset, window, cx).into()}),- ));+ external_payload: None,+ });+ }++ /// Registers a callback resolving a payload to offer the platform if a drag started by this+ /// element leaves the window. It is invoked at most once per drag gesture, when the pointer+ /// exits the viewport. Must be called after [`Self::on_drag`], with the same dragged value+ /// type `T`.+ pub fn external_drag_payload<T>(+ &mut self,+ resolver: impl Fn(&T, &mut Window, &mut App) -> Option<ExternalDragPayload> + 'static,+ ) where+ Self: Sized,+ T: 'static,+ {+ let Some(drag_listener) = self.drag_listener.as_mut() else {+ debug_assert!(false, "external_drag_payload must be called after on_drag");+ return;+ };+ debug_assert!(+ drag_listener.value.as_ref().type_id() == TypeId::of::<T>(),+ "external_drag_payload must use the same dragged value type as on_drag"+ );+ debug_assert!(+ drag_listener.external_payload.is_none(),+ "calling external_drag_payload more than once on the same element is not supported"+ );+ drag_listener.external_payload = Some(Box::new(move |value, window, cx| {+ resolver(value.downcast_ref::<T>()?, window, cx)+ }));}/// Bind the given callback on the hover start and end events of this element. Note that the boolean@@ -1519,6 +1548,23 @@ pub trait StatefulInteractiveElement: InteractiveElement {self}+ /// Registers a callback resolving a payload to offer the platform if a drag started by this+ /// element leaves the window. It is invoked at most once per drag gesture, when the pointer+ /// exits the viewport. Must be called after [`Self::on_drag`], with the same dragged value+ /// type `T`.+ /// The fluent API equivalent to [`Interactivity::external_drag_payload`].+ fn external_drag_payload<T>(+ mut self,+ resolver: impl Fn(&T, &mut Window, &mut App) -> Option<ExternalDragPayload> + 'static,+ ) -> Self+ where+ Self: Sized,+ T: 'static,+ {+ self.interactivity().external_drag_payload(resolver);+ self+ }+/// Bind the given callback on the hover start and end events of this element. Note that the boolean/// passed to the callback is true when the hover starts and false when it ends./// The fluent API equivalent to [`Interactivity::on_hover`].@@ -1586,8 +1632,14 @@ pub(crate) type PinchListener =pub(crate) type ClickListener = Rc<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static>;-pub(crate) type DragListener =- Box<dyn Fn(&dyn Any, Point<Pixels>, &mut Window, &mut App) -> AnyView + 'static>;+pub(crate) struct DragListener {+ value: Arc<dyn Any>,+ render: Box<dyn Fn(&dyn Any, Point<Pixels>, &mut Window, &mut App) -> AnyView + 'static>,+ external_payload: Option<ExternalDragPayloadResolver>,+}++type ExternalDragPayloadResolver =+ Box<dyn Fn(&dyn Any, &mut Window, &mut App) -> Option<ExternalDragPayload> + 'static>;type DropListener = Box<dyn Fn(&dyn Any, &mut Window, &mut App) + 'static>;@@ -1994,7 +2046,7 @@ pub struct Interactivity {pub(crate) can_drop_predicate: Option<CanDropPredicate>,pub(crate) click_listeners: Vec<ClickListener>,pub(crate) aux_click_listeners: Vec<ClickListener>,- pub(crate) drag_listener: Option<(Arc<dyn Any>, DragListener)>,+ pub(crate) drag_listener: Option<DragListener>,pub(crate) hover_listener: Option<Box<dyn Fn(&bool, &mut Window, &mut App)>>,pub(crate) tooltip_builder: Option<TooltipBuilder>,pub(crate) tooltip_show_delay: Option<Duration>,@@ -2767,18 +2819,31 @@ impl Interactivity {if let Some(mouse_down) = pending_mouse_down.clone()&& !cx.has_active_drag()&& (event.position - mouse_down.position).magnitude() > DRAG_THRESHOLD- && let Some((drag_value, drag_listener)) = drag_listener.take()+ && let Some(listener) = drag_listener.take()&& mouse_down.button == MouseButton::Left{*clicked_state.borrow_mut() = ElementClickedState::default();let cursor_offset = event.position - hitbox.origin;- let drag =- (drag_listener)(drag_value.as_ref(), cursor_offset, window, cx);+ let drag = (listener.render)(+ listener.value.as_ref(),+ cursor_offset,+ window,+ cx,+ );+ let external_payload_source =+ listener.external_payload.map(|external_payload| {+ let value = listener.value.clone();+ Box::new(move |window: &mut Window, cx: &mut App| {+ external_payload(value.as_ref(), window, cx)+ })+ as ExternalDragPayloadSource+ });cx.active_drag = Some(AnyDrag {view: drag,- value: drag_value,+ value: listener.value,cursor_offset,cursor_style: drag_cursor_style,+ external_payload_source,});pending_mouse_down.take();window.refresh();diff --git a/crates/gpui/src/interactive.rs b/crates/gpui/src/interactive.rsindex 1feee49edb0..94bf4ed9ae8 100644--- a/crates/gpui/src/interactive.rs+++ b/crates/gpui/src/interactive.rs@@ -691,6 +691,31 @@ impl ExternalPaths {}}+/// Data offered to the platform when an internal drag leaves the window and is+/// promoted to a native drag session.+#[derive(Debug, Clone, Eq, PartialEq)]+pub enum ExternalDragPayload {+ /// Real on-disk paths, handed to the platform as an outbound file drag.+ Files(FileDragPaths),+}++/// Paths handed to the platform for a native file drag. Directory metadata is+/// provided by the caller to avoid querying it when the platform drag starts.+#[derive(Debug, Clone, Default, Eq, PartialEq)]+pub struct FileDragPaths(SmallVec<[(PathBuf, bool); 2]>);++impl FileDragPaths {+ /// Creates a native file-drag payload from paths paired with whether each path is a directory.+ pub fn new(entries: impl IntoIterator<Item = (PathBuf, bool)>) -> Self {+ Self(entries.into_iter().collect())+ }++ /// The dragged paths, each paired with whether it is a directory.+ pub fn entries(&self) -> &[(PathBuf, bool)] {+ &self.0+ }+}+impl Render for ExternalPaths {fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {// the platform will render icons for the dragged filesdiff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rsindex bb9b4f890da..f60d10dfc9a 100644--- a/crates/gpui/src/platform.rs+++ b/crates/gpui/src/platform.rs@@ -36,11 +36,11 @@ pub(crate) type PlatformScreenCaptureFrame = core_video::image_buffer::CVImageBuuse crate::{Action, AnyWindowHandle, App, AsyncWindowContext, BackgroundExecutor, Bounds,- DEFAULT_WINDOW_SIZE, DevicePixels, DispatchEventResult, Edges, Font, FontId, FontMetrics,- FontRun, ForegroundExecutor, GlyphId, GpuSpecs, Hsla, ImageSource, Keymap, LineLayout, Pixels,- PlatformGestures, PlatformInput, Point, Priority, RenderGlyphParams, RenderImage,- RenderImageParams, RenderSvgParams, Scene, ShapedGlyph, ShapedRun, SharedString, Size,- SvgRenderer, SystemWindowTab, Task, Window, WindowControlArea, hash, point, px, size,+ DEFAULT_WINDOW_SIZE, DevicePixels, DispatchEventResult, Edges, ExternalDragPayload, Font,+ FontId, FontMetrics, FontRun, ForegroundExecutor, GlyphId, GpuSpecs, Hsla, ImageSource, Keymap,+ LineLayout, Pixels, PlatformGestures, PlatformInput, Point, Priority, RenderGlyphParams,+ RenderImage, RenderImageParams, RenderSvgParams, Scene, ShapedGlyph, ShapedRun, SharedString,+ Size, SvgRenderer, SystemWindowTab, Task, Window, WindowControlArea, hash, point, px, size,};#[cfg(any(target_os = "linux", target_os = "freebsd"))]use anyhow::bail;@@ -886,6 +886,12 @@ pub trait PlatformWindow: HasWindowHandle + HasDisplayHandle {fn request_decorations(&self, _decorations: WindowDecorations) {}fn show_window_menu(&self, _position: Point<Pixels>) {}fn start_window_move(&self) {}+ fn can_start_external_drag(&self) -> bool {+ false+ }+ fn start_external_drag(&self, _payload: &ExternalDragPayload) -> bool {+ false+ }fn start_window_resize(&self, _edge: ResizeEdge) {}fn set_exclusive_zone(&self, _zone: Pixels) {}#[cfg(all(target_os = "linux", feature = "wayland"))]diff --git a/crates/gpui/src/platform/test/window.rs b/crates/gpui/src/platform/test/window.rsindex ea1edf5a917..84de0d28d7a 100644--- a/crates/gpui/src/platform/test/window.rs+++ b/crates/gpui/src/platform/test/window.rs@@ -11,6 +11,7 @@ use image::RgbaImage;use parking_lot::Mutex;use raw_window_handle::{HasDisplayHandle, HasWindowHandle};use std::{+ path::PathBuf,rc::{Rc, Weak},sync::{self, Arc},};@@ -37,6 +38,8 @@ pub(crate) struct TestWindowState {input_handler: Option<PlatformInputHandler>,is_fullscreen: bool,appearance: WindowAppearance,+ external_drag_files: Vec<(PathBuf, bool)>,+ start_external_drag_result: bool,}#[derive(Clone)]@@ -91,6 +94,8 @@ impl TestWindow {input_handler: None,is_fullscreen: false,appearance: WindowAppearance::Light,+ external_drag_files: Vec::new(),+ start_external_drag_result: false,})))}@@ -138,6 +143,14 @@ impl TestWindow {self.0.lock().input_callback = Some(callback);!result.propagate}++ pub fn external_drag_files(&self) -> Vec<(PathBuf, bool)> {+ self.0.lock().external_drag_files.clone()+ }++ pub fn set_start_external_drag_result(&self, result: bool) {+ self.0.lock().start_external_drag_result = result;+ }}impl PlatformWindow for TestWindow {@@ -352,6 +365,20 @@ impl PlatformWindow for TestWindow {unimplemented!()}+ fn can_start_external_drag(&self) -> bool {+ true+ }++ fn start_external_drag(&self, payload: &crate::ExternalDragPayload) -> bool {+ let mut state = self.0.lock();+ match payload {+ crate::ExternalDragPayload::Files(paths) => {+ state.external_drag_files.extend_from_slice(paths.entries());+ }+ }+ state.start_external_drag_result+ }+fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}fn gpu_specs(&self) -> Option<GpuSpecs> {diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rsindex c2e17376413..4c2ecbccfc8 100644--- a/crates/gpui/src/window.rs+++ b/crates/gpui/src/window.rs@@ -4947,6 +4947,7 @@ impl Window {view: cx.new(|_| paths).into(),cursor_offset: position,cursor_style: None,+ external_payload_source: None,});}PlatformInput::MouseMove(MouseMoveEvent {@@ -4988,6 +4989,10 @@ impl Window {self.dispatch_key_event(any_key_event, cx);}+ // Must run after the move is dispatched: the platform owns the gesture afterwards, so this+ // is the last chance for drag listeners to see the pointer leave and reset their state.+ self.promote_external_drag_to_platform(&event, cx);+if self.invalidator.update_count() > update_count_before {self.input_rate_tracker.borrow_mut().record_input();#[cfg(feature = "input-latency-histogram")]@@ -5004,6 +5009,34 @@ impl Window {}}+ fn promote_external_drag_to_platform(&mut self, event: &PlatformInput, cx: &mut App) {+ let PlatformInput::MouseMove(mouse_move) = event else {+ return;+ };+ if mouse_move.pressed_button != Some(MouseButton::Left) {+ return;+ }+ if Bounds::new(Point::default(), self.viewport_size).contains(&mouse_move.position) {+ return;+ }+ if !self.platform_window.can_start_external_drag() {+ return;+ }+ let Some(payload_source) = cx+ .active_drag+ .as_mut()+ .and_then(|drag| drag.external_payload_source.take())+ else {+ return;+ };+ let Some(payload) = payload_source(self, cx) else {+ return;+ };+ if self.platform_window.start_external_drag(&payload) {+ cx.stop_active_drag(self);+ }+ }+fn dispatch_mouse_event(&mut self, event: &dyn Any, cx: &mut App) {let hit_test = self.rendered_frame.hit_test(self.mouse_position());if hit_test != self.mouse_hit_test {@@ -6685,12 +6718,18 @@ pub fn outline(#[cfg(test)]mod tests {- use std::{cell::Cell, rc::Rc};+ use std::{+ cell::{Cell, RefCell},+ path::PathBuf,+ rc::Rc,+ };use crate::{- AppContext as _, Bounds, Context, FocusHandle, InteractiveElement as _, IntoElement,- ParentElement, Pixels, Render, Styled, TestAppContext, Window, WindowAppearance,- WindowOptions, canvas, div, px, size,+ AnyWindowHandle, AppContext as _, Bounds, Context, DragMoveEvent, Empty,+ ExternalDragPayload, FileDragPaths, FocusHandle, InputEvent as _, InteractiveElement as _,+ IntoElement, MouseButton, MouseDownEvent, MouseMoveEvent, ParentElement, Pixels, Point,+ Render, StatefulInteractiveElement as _, Styled, TestAppContext, Window, WindowAppearance,+ WindowOptions, canvas, div, point, px, size,};struct EmptyView;@@ -6841,6 +6880,145 @@ mod tests {assert_eq!(child_bounds.get().size, size(px(300.), px(200.)));}+ struct FileDragView {+ path: PathBuf,+ observed_drag_moves: Rc<RefCell<Vec<Point<Pixels>>>>,+ }++ impl Render for FileDragView {+ fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {+ div()+ .id("file-drag")+ .size_full()+ .on_drag(self.path.clone(), |_, _, _, cx| cx.new(|_| Empty))+ .external_drag_payload(|path: &PathBuf, _, _| {+ Some(ExternalDragPayload::Files(FileDragPaths::new([(+ path.clone(),+ true,+ )])))+ })+ .on_drag_move({+ let observed_drag_moves = self.observed_drag_moves.clone();+ move |event: &DragMoveEvent<PathBuf>, _, _| {+ observed_drag_moves.borrow_mut().push(event.event.position);+ }+ })+ }+ }++ #[gpui::test]+ fn file_drag_is_promoted_once_after_leaving_the_viewport(cx: &mut TestAppContext) {+ struct Drag {+ window: AnyWindowHandle,+ observed_drag_moves: Rc<RefCell<Vec<Point<Pixels>>>>,+ }++ fn start_drag(cx: &mut TestAppContext, path: PathBuf, platform_result: bool) -> Drag {+ let observed_drag_moves = Rc::new(RefCell::new(Vec::new()));+ let window: AnyWindowHandle = cx+ .add_window({+ let observed_drag_moves = observed_drag_moves.clone();+ move |_, _| FileDragView {+ path,+ observed_drag_moves,+ }+ })+ .into();+ cx.test_window(window)+ .set_start_external_drag_result(platform_result);++ let update_result = cx.update_window(window, |_, window, cx| {+ window.draw(cx).clear(cx);+ window.dispatch_event(+ MouseDownEvent {+ position: point(px(10.), px(10.)),+ button: MouseButton::Left,+ modifiers: Default::default(),+ click_count: 1,+ first_mouse: false,+ }+ .to_platform_input(),+ cx,+ );+ window.dispatch_event(+ MouseMoveEvent {+ position: point(px(20.), px(20.)),+ pressed_button: Some(MouseButton::Left),+ modifiers: Default::default(),+ }+ .to_platform_input(),+ cx,+ );+ assert!(cx.active_drag.is_some());+ });+ assert!(+ update_result.is_ok(),+ "failed to start drag: {update_result:?}"+ );++ assert!(cx.test_window(window).external_drag_files().is_empty());+ Drag {+ window,+ observed_drag_moves,+ }+ }++ let successful_path = PathBuf::from("/tmp/successful-drag");+ let successful = start_drag(cx, successful_path.clone(), true);+ let outside_position = point(px(-1.), px(20.));+ let update_result = cx.update_window(successful.window, |_, window, cx| {+ window.dispatch_event(+ MouseMoveEvent {+ position: outside_position,+ pressed_button: Some(MouseButton::Left),+ modifiers: Default::default(),+ }+ .to_platform_input(),+ cx,+ );+ assert!(cx.active_drag.is_none());+ });+ assert!(+ update_result.is_ok(),+ "failed to promote drag: {update_result:?}"+ );+ assert_eq!(+ cx.test_window(successful.window).external_drag_files(),+ [(successful_path, true)]+ );+ // Views must still see the move that leaves the window, otherwise they never learn to tear+ // down the drag state they built up while the pointer was inside.+ assert_eq!(+ successful.observed_drag_moves.borrow().last(),+ Some(&outside_position)+ );++ let failed_path = PathBuf::from("/tmp/failed-drag");+ let failed = start_drag(cx, failed_path.clone(), false);+ let update_result = cx.update_window(failed.window, |_, window, cx| {+ for x_position in [-1., -2.] {+ window.dispatch_event(+ MouseMoveEvent {+ position: point(px(x_position), px(20.)),+ pressed_button: Some(MouseButton::Left),+ modifiers: Default::default(),+ }+ .to_platform_input(),+ cx,+ );+ }+ assert!(cx.active_drag.is_some());+ });+ assert!(+ update_result.is_ok(),+ "failed to retain drag after platform failure: {update_result:?}"+ );+ assert_eq!(+ cx.test_window(failed.window).external_drag_files(),+ [(failed_path, true)]+ );+ }+struct FocusForwarder {a: FocusHandle,b: FocusHandle,diff --git a/crates/gpui_macos/src/window.rs b/crates/gpui_macos/src/window.rsindex cf9beb02284..cb4e3cb7528 100644--- a/crates/gpui_macos/src/window.rs+++ b/crates/gpui_macos/src/window.rs@@ -9,7 +9,7 @@ use anyhow::Result;use block::ConcreteBlock;use cocoa::{appkit::{- NSApplication, NSBackingStoreBuffered, NSColor, NSEventModifierFlags,+ NSApplication, NSBackingStoreBuffered, NSColor, NSEvent, NSEventModifierFlags, NSEventType,NSFilenamesPboardType, NSPasteboard, NSRequestUserAttentionType, NSScreen, NSView,NSViewHeightSizable, NSViewWidthSizable, NSVisualEffectMaterial, NSVisualEffectState,NSVisualEffectView, NSWindow, NSWindowCollectionBehavior, NSWindowOcclusionState,@@ -24,13 +24,13 @@ use cocoa::{};use dispatch2::DispatchQueue;use gpui::{- AnyWindowHandle, BackgroundExecutor, Bounds, Capslock, CursorStyle, ExternalPaths,- FileDropEvent, ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers, ModifiersChangedEvent,- MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas,- PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point, PromptButton,- PromptLevel, RequestFrameOptions, SharedString, Size, SystemWindowTab, WindowAppearance,- WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowKind, WindowParams, point,- px, size,+ AnyWindowHandle, BackgroundExecutor, Bounds, Capslock, CursorStyle, ExternalDragPayload,+ ExternalPaths, FileDropEvent, ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers,+ ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,+ PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point,+ PromptButton, PromptLevel, RequestFrameOptions, SharedString, Size, SystemWindowTab,+ WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowKind,+ WindowParams, point, px, size,};#[cfg(any(test, feature = "test-support"))]use image::RgbaImage;@@ -49,7 +49,7 @@ use objc::{runtime::{BOOL, Class, NO, Object, Protocol, Sel, YES},sel, sel_impl,};-use objc2::rc::Retained;+use objc2::{rc::Retained, runtime::AnyObject as Objc2Object};use objc2_app_kit::{NSBeep, NSButton as Objc2NSButton, NSView as Objc2NSView, NSWindow as Objc2NSWindow,NSWindowButton as Objc2NSWindowButton,@@ -60,9 +60,10 @@ use raw_window_handle as rwh;use smallvec::SmallVec;use std::{cell::Cell,- ffi::{CStr, c_void},+ ffi::{CStr, CString, c_void},mem,ops::Range,+ os::unix::ffi::OsStrExt,path::PathBuf,ptr::{self, NonNull},rc::Rc,@@ -108,6 +109,10 @@ type NSDragOperation = NSUInteger;const NSDragOperationNone: NSDragOperation = 0;#[allow(non_upper_case_globals)]const NSDragOperationCopy: NSDragOperation = 1;+#[allow(non_upper_case_globals)]+const NSDragOperationMove: NSDragOperation = 16;+const NSDRAGGING_CONTEXT_OUTSIDE_APPLICATION: NSInteger = 0;+const NSDRAGGING_CONTEXT_WITHIN_APPLICATION: NSInteger = 1;#[derive(PartialEq)]pub enum UserTabbingPreference {Never,@@ -115,6 +120,12 @@ pub enum UserTabbingPreference {InFullScreen,}+#[link(name = "AppKit", kind = "framework")]+unsafe extern "C" {+ // AppKit constant naming the icon component of an NSDraggingImageComponent.+ #[allow(non_upper_case_globals)]+ static NSDraggingImageComponentIconKey: id;+}#[ctor(unsafe)]unsafe fn build_classes() {unsafe {@@ -428,6 +439,17 @@ unsafe fn build_window_class(name: &'static str, superclass: &Class) -> *const Cconclude_drag_operation as extern "C" fn(&Object, Sel, id),);+ decl.add_protocol(Protocol::get("NSDraggingSource").unwrap());+ decl.add_method(+ sel!(draggingSession:sourceOperationMaskForDraggingContext:),+ dragging_session_source_operation_mask+ as extern "C" fn(&Object, Sel, id, NSInteger) -> NSDragOperation,+ );+ decl.add_method(+ sel!(draggingSession:endedAtPoint:operation:),+ dragging_session_ended as extern "C" fn(&Object, Sel, id, NSPoint, NSDragOperation),+ );+decl.add_method(sel!(addTitlebarAccessoryViewController:),add_titlebar_accessory_view_controller as extern "C" fn(&Object, Sel, id),@@ -497,6 +519,7 @@ struct MacWindowState {appearance_changed_callback: Option<Box<dyn FnMut()>>,input_handler: Option<PlatformInputHandler>,last_key_equivalent: Option<KeyDownEvent>,+ last_left_mouse_down_event: Option<Retained<Objc2Object>>,synthetic_drag_counter: usize,traffic_light_position: Option<Point<Pixels>>,traffic_light_frames: Option<TrafficLightFrames>,@@ -898,6 +921,7 @@ impl MacWindow {appearance_changed_callback: None,input_handler: None,last_key_equivalent: None,+ last_left_mouse_down_event: None,synthetic_drag_counter: 0,traffic_light_position: titlebar.as_ref()@@ -1820,6 +1844,135 @@ impl PlatformWindow for MacWindow {}}+ fn can_start_external_drag(&self) -> bool {+ true+ }++ fn start_external_drag(&self, payload: &ExternalDragPayload) -> bool {+ let ExternalDragPayload::Files(paths) = payload;+ if paths.entries().is_empty() {+ log::warn!("start_external_drag declined: no paths");+ return false;+ }++ let (native_view, native_window, last_left_mouse_down_event) = {+ let state = self.0.lock();+ (+ state.native_view.as_ptr(),+ state.native_window,+ state.last_left_mouse_down_event.clone(),+ )+ };++ let Some(last_left_mouse_down_event) = last_left_mouse_down_event else {+ log::warn!("start_external_drag declined: no retained left mouse down event");+ return false;+ };++ // SAFETY: This method runs on the AppKit/foreground path during drag initiation. The+ // native view/window are retained by MacWindowState, copied out under a short lock above,+ // and Objective-C results that may be nil are checked before use.+ unsafe {+ let event: id = Retained::as_ptr(&last_left_mouse_down_event)+ .cast_mut()+ .cast();+ let dragging_items: id = msg_send![class!(NSMutableArray), array];+ // AppKit keeps this frame's distance from the event's location as the drag image's+ // offset from the cursor, so it has to stay anchored on `event`.+ let location: NSPoint = msg_send![event, locationInWindow];+ let frame = NSRect::new(+ NSPoint::new(location.x - 16., location.y - 16.),+ NSSize::new(32., 32.),+ );++ for (path, is_directory) in paths.entries() {+ // Preserve non-UTF-8 paths+ let Ok(path_bytes) = CString::new(path.as_os_str().as_bytes()) else {+ log::warn!("start_external_drag skipped path containing an interior nul byte");+ continue;+ };++ let url: id = msg_send![+ class!(NSURL),+ fileURLWithFileSystemRepresentation: path_bytes.as_ptr()+ isDirectory: is_directory.to_objc()+ relativeToURL: nil+ ];++ if url.is_null() {+ log::warn!("start_external_drag skipped path with nil NSURL");+ continue;+ }++ let item: id = msg_send![class!(NSDraggingItem), alloc];+ let item: id = msg_send![item, initWithPasteboardWriter: url];+ if item.is_null() {+ log::warn!("start_external_drag declined: NSDraggingItem allocation failed");+ continue;+ }++ // Resolve drag images lazily via `imageComponentsProvider` (Apple's+ // recommendation for large item counts), and by file *type* rather than+ // `iconForFile:`, which can synchronously hit LaunchServices, network+ // mounts, or iCloud for every selected path and beachball drag startup.+ // `iconForFileType:` is deprecated in favor of `iconForContentType:`,+ // but the replacement requires macOS 11 and we target 10.15.+ let file_type = if *is_directory {+ "public.folder".to_string()+ } else {+ path.extension()+ .and_then(|extension| extension.to_str())+ .map(|extension| extension.to_string())+ .unwrap_or_else(|| "public.data".to_string())+ };+ let provider = ConcreteBlock::new(move || -> id {+ let component: id = msg_send![+ class!(NSDraggingImageComponent),+ draggingImageComponentWithKey: NSDraggingImageComponentIconKey+ ];+ let workspace: id = msg_send![class!(NSWorkspace), sharedWorkspace];+ let icon: id = msg_send![workspace, iconForFileType: ns_string(&file_type)];+ let _: () = msg_send![component, setContents: icon];+ // Component frames are relative to the item's dragging frame.+ let _: () = msg_send![+ component,+ setFrame: NSRect::new(NSPoint::new(0., 0.), NSSize::new(32., 32.))+ ];+ msg_send![class!(NSArray), arrayWithObject: component]+ });+ let provider = provider.copy();+ let _: () = msg_send![item, setDraggingFrame: frame];+ let _: () = msg_send![item, setImageComponentsProvider: provider];+ let _: () = msg_send![dragging_items, addObject: item];+ let _: () = msg_send![item, release];+ }++ let count: NSUInteger = msg_send![dragging_items, count];+ if count == 0 {+ log::warn!("start_external_drag declined: no dragging items");+ return false;+ }++ let session: id = msg_send![+ native_view,+ beginDraggingSessionWithItems: dragging_items+ event: event+ source: native_window+ ];++ let started = !session.is_null();+ if started {+ self.0.lock().synthetic_drag_counter += 1;+ }+ log::debug!(+ "start_external_drag completed: started={}, item_count={}",+ started,+ count+ );+ started+ }+ }+fn play_system_bell(&self) {NSBeep()}@@ -2235,6 +2388,19 @@ extern "C" fn handle_view_event(this: &Object, _: Sel, native_event: id) {let weak_window_state = Arc::downgrade(&window_state);let mut lock = window_state.as_ref().lock();let window_height = lock.content_size().height;+ let native_event_type = unsafe { native_event.eventType() };+ match native_event_type {+ NSEventType::NSLeftMouseDown => {+ // AppKit owns `native_event` for the callback; retain it so the drag session can still+ // be started later, once the pointer leaves the window.+ lock.last_left_mouse_down_event =+ unsafe { Retained::retain(native_event.cast::<Objc2Object>()) };+ }+ NSEventType::NSLeftMouseUp => {+ lock.last_left_mouse_down_event = None;+ }+ _ => {}+ }let event = unsafe { platform_input_from_native(native_event, Some(window_height)) };if let Some(mut event) = event {@@ -2898,7 +3064,15 @@ fn screen_point_to_gpui_point(this: &Object, position: NSPoint) -> Point<Pixels>point(px(window_x as f32), px(window_y as f32))}+fn is_drag_from_this_window(this: &Object, dragging_info: id) -> bool {+ let source: id = unsafe { msg_send![dragging_info, draggingSource] };+ std::ptr::eq(source as *const Object, this as *const Object)+}+extern "C" fn dragging_entered(this: &Object, _: Sel, dragging_info: id) -> NSDragOperation {+ if is_drag_from_this_window(this, dragging_info) {+ return NSDragOperationNone;+ }let window_state = unsafe { get_window_state(this) };let position = drag_event_position(&window_state, dragging_info);let paths = external_paths_from_event(dragging_info);@@ -2911,6 +3085,9 @@ extern "C" fn dragging_entered(this: &Object, _: Sel, dragging_info: id) -> NSDr}extern "C" fn dragging_updated(this: &Object, _: Sel, dragging_info: id) -> NSDragOperation {+ if is_drag_from_this_window(this, dragging_info) {+ return NSDragOperationNone;+ }let window_state = unsafe { get_window_state(this) };let position = drag_event_position(&window_state, dragging_info);if send_file_drop_event(window_state, FileDropEvent::Pending { position }) {@@ -2920,12 +3097,18 @@ extern "C" fn dragging_updated(this: &Object, _: Sel, dragging_info: id) -> NSDr}}-extern "C" fn dragging_exited(this: &Object, _: Sel, _: id) {+extern "C" fn dragging_exited(this: &Object, _: Sel, dragging_info: id) {+ if is_drag_from_this_window(this, dragging_info) {+ return;+ }let window_state = unsafe { get_window_state(this) };send_file_drop_event(window_state, FileDropEvent::Exited);}extern "C" fn perform_drag_operation(this: &Object, _: Sel, dragging_info: id) -> BOOL {+ if is_drag_from_this_window(this, dragging_info) {+ return NO;+ }let window_state = unsafe { get_window_state(this) };let position = drag_event_position(&window_state, dragging_info);send_file_drop_event(window_state, FileDropEvent::Submit { position }).to_objc()@@ -2953,6 +3136,41 @@ extern "C" fn conclude_drag_operation(this: &Object, _: Sel, _: id) {send_file_drop_event(window_state, FileDropEvent::Exited);}+extern "C" fn dragging_session_source_operation_mask(+ _: &Object,+ _: Sel,+ _: id,+ context: NSInteger,+) -> NSDragOperation {+ let operation = match context {+ NSDRAGGING_CONTEXT_OUTSIDE_APPLICATION => NSDragOperationCopy,+ NSDRAGGING_CONTEXT_WITHIN_APPLICATION => NSDragOperationCopy | NSDragOperationMove,+ _ => NSDragOperationCopy | NSDragOperationMove,+ };+ log::debug!(+ "dragging_session_source_operation_mask: context={}, operation={}",+ context,+ operation+ );+ operation+}++extern "C" fn dragging_session_ended(+ this: &Object,+ _: Sel,+ _: id,+ _: NSPoint,+ operation: NSDragOperation,+) {+ log::debug!("dragging_session_ended operation={operation}");+ // SAFETY: AppKit invokes this selector on the GPUIWindow instance registered in build_classes,+ // which always has WINDOW_STATE_IVAR initialized to the owning MacWindowState.+ let window_state = unsafe { get_window_state(this) };+ let mut lock = window_state.lock();+ lock.synthetic_drag_counter += 1;+ lock.last_left_mouse_down_event = None;+}+async fn synthetic_drag(window_state: Weak<Mutex<MacWindowState>>,drag_id: usize,diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rsindex 9f79115d282..67fd8b1f784 100644--- a/crates/project_panel/src/project_panel.rs+++ b/crates/project_panel/src/project_panel.rs@@ -22,12 +22,13 @@ use git_ui::file_diff_view::FileDiffView;use gpui::{Action, AnyElement, App, AsyncWindowContext, Bounds, ClipboardEntry as GpuiClipboardEntry,ClipboardItem, Context, CursorStyle, DismissEvent, Div, DragMoveEvent, Entity, EventEmitter,- ExternalPaths, FocusHandle, Focusable, FontWeight, Hsla, InteractiveElement, KeyContext,- ListHorizontalSizingBehavior, ListSizingBehavior, Modifiers, ModifiersChangedEvent,- MouseButton, MouseDownEvent, MouseExitEvent, ParentElement, PathPromptOptions, Pixels, Point,- PromptLevel, Render, ScrollStrategy, Stateful, Styled, Subscription, Task,- UniformListScrollHandle, WeakEntity, Window, actions, anchored, deferred, div, hsla,- linear_color_stop, linear_gradient, point, px, size, transparent_white, uniform_list,+ ExternalDragPayload, ExternalPaths, FileDragPaths, FocusHandle, Focusable, FontWeight, Hsla,+ InteractiveElement, KeyContext, ListHorizontalSizingBehavior, ListSizingBehavior, Modifiers,+ ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseExitEvent, ParentElement,+ PathPromptOptions, Pixels, Point, PromptLevel, Render, ScrollStrategy, Stateful, Styled,+ Subscription, Task, UniformListScrollHandle, WeakEntity, Window, actions, anchored, deferred,+ div, hsla, linear_color_stop, linear_gradient, point, px, size, transparent_white,+ uniform_list,};use language::DiagnosticSeverity;use markdown_preview::markdown_preview_view::MarkdownPreviewView;@@ -4760,6 +4761,43 @@ impl ProjectPanel {|| cfg!(not(target_os = "macos")) && modifiers.control}+ fn file_drag_paths_for_selections(+ project: &Entity<Project>,+ selections: impl IntoIterator<Item = SelectedEntry>,+ cx: &App,+ ) -> Option<FileDragPaths> {+ let project = project.read(cx);+ let paths = selections+ .into_iter()+ .filter_map(|selection| {+ let worktree = project.worktree_for_id(selection.worktree_id, cx)?.read(cx);+ if !worktree.is_local() {+ return None;+ }+ let entry = worktree.entry_for_id(selection.entry_id)?;+ Some((worktree.absolutize(&entry.path), entry.is_dir()))+ })+ .collect::<SmallVec<[_; 2]>>();++ (!paths.is_empty()).then(|| FileDragPaths::new(paths))+ }++ fn external_paths_for_dragged_selection(+ &self,+ selections: &DraggedSelection,+ cx: &App,+ ) -> Option<FileDragPaths> {+ let resolved_selections = selections+ .items()+ .map(|selection| SelectedEntry {+ worktree_id: selection.worktree_id,+ entry_id: self.resolve_entry(selection.entry_id),+ })+ .collect::<BTreeSet<SelectedEntry>>();+ let entries = self.disjoint_entries(resolved_selections, cx);+ Self::file_drag_paths_for_selections(&self.project, entries, cx)+ }+fn drag_onto(&mut self,selections: &DraggedSelection,@@ -5944,6 +5982,15 @@ impl ProjectPanel {})}})+ .external_drag_payload({+ let project_panel = cx.entity();+ move |selection: &DraggedSelection, _window, cx| {+ project_panel+ .read(cx)+ .external_paths_for_dragged_selection(selection, cx)+ .map(ExternalDragPayload::Files)+ }+ }).on_drop(cx.listener(move |this, selections: &DraggedSelection, window, cx| {this.clear_drag_state(cx);diff --git a/crates/project_panel/src/project_panel_tests.rs b/crates/project_panel/src/project_panel_tests.rsindex 64285792d75..74246ec6b23 100644--- a/crates/project_panel/src/project_panel_tests.rs+++ b/crates/project_panel/src/project_panel_tests.rs@@ -4595,6 +4595,231 @@ async fn test_rename_survives_window_deactivation(cx: &mut gpui::TestAppContext));}+#[gpui::test]+async fn test_file_drag_paths_use_worktree_snapshot(cx: &mut gpui::TestAppContext) {+ init_test(cx);++ let temp_dir = tempfile::tempdir().unwrap();+ let root_path = temp_dir.path();+ let existing_a = root_path.join("existing_a.txt");+ let existing_b = root_path.join("existing_b.txt");+ let deleted_directory = root_path.join("deleted_dir");+ std::fs::write(&existing_a, "a").unwrap();+ std::fs::write(&existing_b, "b").unwrap();+ std::fs::create_dir(&deleted_directory).unwrap();+ std::fs::write(deleted_directory.join("nested.txt"), "nested").unwrap();++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree_from_real_fs(root_path, root_path).await;+ std::fs::remove_dir_all(&deleted_directory).unwrap();++ let project = Project::test(fs.clone(), [root_path], cx).await;+ let (worktree_id, existing_a_id, existing_b_id, deleted_directory_id) = cx.update(|cx| {+ let project = project.read(cx);+ let worktree = project.worktrees(cx).next().unwrap();+ let worktree = worktree.read(cx);+ (+ worktree.id(),+ worktree+ .entry_for_path(rel_path("existing_a.txt"))+ .unwrap()+ .id,+ worktree+ .entry_for_path(rel_path("existing_b.txt"))+ .unwrap()+ .id,+ worktree.entry_for_path(rel_path("deleted_dir")).unwrap().id,+ )+ });++ let dragged_selection = DraggedSelection {+ active_selection: SelectedEntry {+ worktree_id,+ entry_id: existing_a_id,+ },+ marked_selections: Arc::from(vec![+ SelectedEntry {+ worktree_id,+ entry_id: existing_a_id,+ },+ SelectedEntry {+ worktree_id,+ entry_id: existing_b_id,+ },+ SelectedEntry {+ worktree_id,+ entry_id: deleted_directory_id,+ },+ ]),+ };++ let paths = cx+ .update(|cx| {+ ProjectPanel::file_drag_paths_for_selections(+ &project,+ dragged_selection.items().copied(),+ cx,+ )+ })+ .unwrap();++ assert_eq!(+ paths.entries(),+ &[+ (existing_a, false),+ (existing_b, false),+ (deleted_directory, true),+ ]+ );+}++#[gpui::test]+async fn test_external_paths_for_dragged_selection_uses_active_selection_unless_marked(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);++ let temp_dir = tempfile::tempdir().unwrap();+ let root_path = temp_dir.path();+ let active_path = root_path.join("active.txt");+ let marked_path = root_path.join("marked.txt");+ std::fs::write(&active_path, "active").unwrap();+ std::fs::write(&marked_path, "marked").unwrap();++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree_from_real_fs(root_path, root_path).await;++ let project = Project::test(fs.clone(), [root_path], cx).await;+ let (worktree_id, active_id, marked_id) = cx.update(|cx| {+ let project = project.read(cx);+ let worktree = project.worktrees(cx).next().unwrap();+ let worktree = worktree.read(cx);+ (+ worktree.id(),+ worktree.entry_for_path(rel_path("active.txt")).unwrap().id,+ worktree.entry_for_path(rel_path("marked.txt")).unwrap().id,+ )+ });++ let dragged_selection = DraggedSelection {+ active_selection: SelectedEntry {+ worktree_id,+ entry_id: active_id,+ },+ marked_selections: Arc::from(vec![SelectedEntry {+ worktree_id,+ entry_id: marked_id,+ }]),+ };++ let paths = cx+ .update(|cx| {+ ProjectPanel::file_drag_paths_for_selections(+ &project,+ dragged_selection.items().copied(),+ cx,+ )+ })+ .unwrap();++ assert_eq!(paths.entries(), &[(active_path, false)]);+}++#[gpui::test]+async fn test_external_paths_for_dragged_selection_resolves_folded_directory(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ "/root",+ json!({+ "a": {+ "b": {+ "c": {+ "d": {}+ }+ }+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), ["/root".as_ref()], cx).await;+ let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = window+ .read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone())+ .unwrap();+ let cx = &mut VisualTestContext::from_window(window.into(), cx);++ cx.update(|_, cx| {+ let settings = *ProjectPanelSettings::get_global(cx);+ ProjectPanelSettings::override_global(+ ProjectPanelSettings {+ auto_fold_dirs: true,+ ..settings+ },+ cx,+ );+ });++ let panel = workspace.update_in(cx, ProjectPanel::new);+ cx.run_until_parked();+ select_folded_path_with_mark(&panel, "root/a/b/c/d", "root/a/b", cx);++ let dragged_selection = panel.read_with(cx, |panel, _| DraggedSelection {+ active_selection: panel.selection.unwrap(),+ marked_selections: Arc::from(panel.marked_entries.clone()),+ });+ let paths = cx+ .update(|_, cx| {+ panel.read_with(cx, |panel, cx| {+ panel.external_paths_for_dragged_selection(&dragged_selection, cx)+ })+ })+ .unwrap();++ assert_eq!(paths.entries(), &[(PathBuf::from("/root/a/b"), true)]);+}++#[gpui::test]+async fn test_external_paths_for_dragged_selection_skips_remote_worktrees(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree("/local", json!({})).await;+ let project = Project::test(fs.clone(), ["/local".as_ref()], cx).await;++ let remote_worktree = project.update(cx, |project, cx| {+ project.add_test_remote_worktree("/remote/project", cx)+ });+ let remote_worktree_id = remote_worktree.read_with(cx, |worktree, _| worktree.id());++ let dragged_selection = DraggedSelection {+ active_selection: SelectedEntry {+ worktree_id: remote_worktree_id,+ entry_id: ProjectEntryId::from_usize(1),+ },+ marked_selections: Arc::from(vec![SelectedEntry {+ worktree_id: remote_worktree_id,+ entry_id: ProjectEntryId::from_usize(1),+ }]),+ };++ let paths = cx.update(|cx| {+ ProjectPanel::file_drag_paths_for_selections(+ &project,+ dragged_selection.items().copied(),+ cx,+ )+ });++ assert!(paths.is_none());+}+#[gpui::test]async fn test_multiple_marked_entries(cx: &mut gpui::TestAppContext) {init_test_with_editor(cx);