Handle project entry drop render & start fixing drag cancel issues

Co-Authored-By: Kay Simmons <kay@zed.dev>

crates/drag_and_drop/src/drag_and_drop.rs

@@ -1,32 +1,47 @@
+pub mod shared_payloads;
+
 use std::{any::Any, rc::Rc};
 
 use collections::HashSet;
 use gpui::{
-    elements::{MouseEventHandler, Overlay},
+    elements::{Empty, MouseEventHandler, Overlay},
     geometry::{rect::RectF, vector::Vector2F},
     scene::MouseDrag,
     CursorStyle, Element, ElementBox, EventContext, MouseButton, MutableAppContext, RenderContext,
     View, WeakViewHandle,
 };
 
-struct State<V: View> {
+enum State<V: View> {
+    Dragging {
         window_id: usize,
         position: Vector2F,
         region_offset: Vector2F,
         region: RectF,
         payload: Rc<dyn Any + 'static>,
         render: Rc<dyn Fn(Rc<dyn Any>, &mut RenderContext<V>) -> ElementBox>,
+    },
+    Canceled,
 }
 
 impl<V: View> Clone for State<V> {
     fn clone(&self) -> Self {
-        Self {
+        match self {
-            window_id: self.window_id.clone(),
+            State::Dragging {
-            position: self.position.clone(),
+                window_id,
-            region_offset: self.region_offset.clone(),
+                position,
-            region: self.region.clone(),
+                region_offset,
-            payload: self.payload.clone(),
+                region,
-            render: self.render.clone(),
+                payload,
+                render,
+            } => Self::Dragging {
+                window_id: window_id.clone(),
+                position: position.clone(),
+                region_offset: region_offset.clone(),
+                region: region.clone(),
+                payload: payload.clone(),
+                render: render.clone(),
+            },
+            State::Canceled => State::Canceled,
         }
     }
 }
@@ -51,24 +66,27 @@ impl<V: View> DragAndDrop<V> {
     }
 
     pub fn currently_dragged<T: Any>(&self, window_id: usize) -> Option<(Vector2F, Rc<T>)> {
-        self.currently_dragged.as_ref().and_then(
+        self.currently_dragged.as_ref().and_then(|state| {
-            |State {
+            if let State::Dragging {
                 position,
                 payload,
                 window_id: window_dragged_from,
                 ..
-             }| {
+            } = state
+            {
                 if &window_id != window_dragged_from {
                     return None;
                 }
 
                 payload
-                    .clone()
+                    .is::<T>()
-                    .downcast::<T>()
+                    .then(|| payload.clone().downcast::<T>().ok())
-                    .ok()
+                    .flatten()
                     .map(|payload| (position.clone(), payload))
-            },
+            } else {
-        )
+                None
+            }
+        })
     }
 
     pub fn dragging<T: Any>(
@@ -79,9 +97,19 @@ impl<V: View> DragAndDrop<V> {
     ) {
         let window_id = cx.window_id();
         cx.update_global::<Self, _, _>(|this, cx| {
-            let (region_offset, region) =
+            this.notify_containers_for_window(window_id, cx);
-                if let Some(previous_state) = this.currently_dragged.as_ref() {
+
-                    (previous_state.region_offset, previous_state.region)
+            if matches!(this.currently_dragged, Some(State::Canceled)) {
+                return;
+            }
+
+            let (region_offset, region) = if let Some(State::Dragging {
+                region_offset,
+                region,
+                ..
+            }) = this.currently_dragged.as_ref()
+            {
+                (*region_offset, *region)
             } else {
                 (
                     event.region.origin() - event.prev_mouse_position,
@@ -89,7 +117,7 @@ impl<V: View> DragAndDrop<V> {
                 )
             };
 
-            this.currently_dragged = Some(State {
+            this.currently_dragged = Some(State::Dragging {
                 window_id,
                 region_offset,
                 region,
@@ -99,30 +127,30 @@ impl<V: View> DragAndDrop<V> {
                     render(payload.downcast_ref::<T>().unwrap(), cx)
                 }),
             });
-
-            this.notify_containers_for_window(window_id, cx);
         });
     }
 
     pub fn render(cx: &mut RenderContext<V>) -> Option<ElementBox> {
-        let currently_dragged = cx.global::<Self>().currently_dragged.clone();
+        enum DraggedElementHandler {}
-
+        cx.global::<Self>()
-        currently_dragged.and_then(
+            .currently_dragged
-            |State {
+            .clone()
+            .and_then(|state| {
+                match state {
+                    State::Dragging {
                         window_id,
                         region_offset,
                         position,
                         region,
                         payload,
                         render,
-             }| {
+                    } => {
                         if cx.window_id() != window_id {
                             return None;
                         }
 
+                        dbg!("Rendered dragging state");
                         let position = position + region_offset;
-
-                enum DraggedElementHandler {}
                         Some(
                             Overlay::new(
                                 MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, cx| {
@@ -131,13 +159,19 @@ impl<V: View> DragAndDrop<V> {
                                 .with_cursor_style(CursorStyle::Arrow)
                                 .on_up(MouseButton::Left, |_, cx| {
                                     cx.defer(|cx| {
-                                cx.update_global::<Self, _, _>(|this, cx| this.stop_dragging(cx));
+                                        cx.update_global::<Self, _, _>(|this, cx| {
+                                            dbg!("Up with dragging state");
+                                            this.finish_dragging(cx)
+                                        });
                                     });
                                     cx.propagate_event();
                                 })
                                 .on_up_out(MouseButton::Left, |_, cx| {
                                     cx.defer(|cx| {
-                                cx.update_global::<Self, _, _>(|this, cx| this.stop_dragging(cx));
+                                        cx.update_global::<Self, _, _>(|this, cx| {
+                                            dbg!("Up out with dragging state");
+                                            this.finish_dragging(cx)
+                                        });
                                     });
                                 })
                                 // Don't block hover events or invalidations
@@ -150,12 +184,57 @@ impl<V: View> DragAndDrop<V> {
                             .with_anchor_position(position)
                             .boxed(),
                         )
-            },
-        )
                     }
 
-    fn stop_dragging(&mut self, cx: &mut MutableAppContext) {
+                    State::Canceled => {
-        if let Some(State { window_id, .. }) = self.currently_dragged.take() {
+                        dbg!("Rendered canceled state");
+                        Some(
+                            MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, _| {
+                                Empty::new()
+                                    .constrained()
+                                    .with_width(0.)
+                                    .with_height(0.)
+                                    .boxed()
+                            })
+                            .on_up(MouseButton::Left, |_, cx| {
+                                cx.defer(|cx| {
+                                    cx.update_global::<Self, _, _>(|this, _| {
+                                        dbg!("Up with canceled state");
+                                        this.currently_dragged = None;
+                                    });
+                                });
+                            })
+                            .on_up_out(MouseButton::Left, |_, cx| {
+                                cx.defer(|cx| {
+                                    cx.update_global::<Self, _, _>(|this, _| {
+                                        dbg!("Up out with canceled state");
+                                        this.currently_dragged = None;
+                                    });
+                                });
+                            })
+                            .boxed(),
+                        )
+                    }
+                }
+            })
+    }
+
+    pub fn cancel_dragging<P: Any>(&mut self, cx: &mut MutableAppContext) {
+        if let Some(State::Dragging {
+            payload, window_id, ..
+        }) = &self.currently_dragged
+        {
+            if payload.is::<P>() {
+                let window_id = *window_id;
+                self.currently_dragged = Some(State::Canceled);
+                dbg!("Canceled");
+                self.notify_containers_for_window(window_id, cx);
+            }
+        }
+    }
+
+    fn finish_dragging(&mut self, cx: &mut MutableAppContext) {
+        if let Some(State::Dragging { window_id, .. }) = self.currently_dragged.take() {
             self.notify_containers_for_window(window_id, cx);
         }
     }

crates/drag_and_drop/src/shared_payloads.rs

@@ -0,0 +1,6 @@
+use std::{path::Path, sync::Arc};
+
+#[derive(Debug, Clone)]
+pub struct DraggedProjectEntry {
+    pub path: Arc<Path>,
+}

crates/project_panel/src/project_panel.rs

@@ -1,5 +1,5 @@
 use context_menu::{ContextMenu, ContextMenuItem};
-use drag_and_drop::Draggable;
+use drag_and_drop::{shared_payloads::DraggedProjectEntry, DragAndDrop, Draggable};
 use editor::{Cancel, Editor};
 use futures::stream::StreamExt;
 use gpui::{
@@ -72,8 +72,8 @@ pub enum ClipboardEntry {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
-struct EntryDetails {
+pub struct EntryDetails {
     filename: String,
     path: Arc<Path>,
     depth: usize,
@@ -605,6 +605,10 @@ impl ProjectPanel {
                     cx.notify();
                 }
             }
+
+            cx.update_global(|drag_and_drop: &mut DragAndDrop<Workspace>, cx| {
+                drag_and_drop.cancel_dragging::<DraggedProjectEntry>(cx);
+            })
         }
     }
 
@@ -1014,8 +1018,8 @@ impl ProjectPanel {
     }
 
     fn render_entry_visual_element<V: View>(
-        details: EntryDetails,
+        details: &EntryDetails,
-        editor: &ViewHandle<Editor>,
+        editor: Option<&ViewHandle<Editor>>,
         padding: f32,
         row_container_style: ContainerStyle,
         style: &ProjectPanelEntry,
@@ -1046,8 +1050,8 @@ impl ProjectPanel {
                 .with_width(style.icon_size)
                 .boxed(),
             )
-            .with_child(if show_editor {
+            .with_child(if show_editor && editor.is_some() {
-                ChildView::new(editor.clone(), cx)
+                ChildView::new(editor.unwrap().clone(), cx)
                     .contained()
                     .with_margin_left(style.icon_spacing)
                     .aligned()
@@ -1099,8 +1103,8 @@ impl ProjectPanel {
             };
 
             Self::render_entry_visual_element(
-                details.clone(),
+                &details,
-                editor,
+                Some(editor),
                 padding,
                 row_container_style,
                 &style,
@@ -1123,22 +1127,26 @@ impl ProjectPanel {
                 position: e.position,
             })
         })
-        .as_draggable(details.clone(), {
+        .as_draggable(
-            let editor = editor.clone();
+            DraggedProjectEntry {
+                path: details.path.clone(),
+            },
+            {
                 let row_container_style = theme.dragged_entry.container;
 
-            move |payload, cx: &mut RenderContext<Workspace>| {
+                move |_, cx: &mut RenderContext<Workspace>| {
                     let theme = cx.global::<Settings>().theme.clone();
                     Self::render_entry_visual_element(
-                    payload.clone(),
+                        &details,
-                    &editor,
+                        None,
                         padding,
                         row_container_style,
                         &theme.project_panel.dragged_entry,
                         cx,
                     )
                 }
-        })
+            },
+        )
         .with_cursor_style(CursorStyle::PointingHand)
         .boxed()
     }

crates/workspace/src/pane/dragged_item_receiver.rs

@@ -1,4 +1,4 @@
-use drag_and_drop::DragAndDrop;
+use drag_and_drop::{shared_payloads::DraggedProjectEntry, DragAndDrop};
 use gpui::{
     color::Color,
     elements::{Canvas, MouseEventHandler, ParentElement, Stack},
@@ -28,12 +28,18 @@ where
     MouseEventHandler::<Tag>::above(region_id, cx, |state, cx| {
         // Observing hovered will cause a render when the mouse enters regardless
         // of if mouse position was accessed before
-        let hovered = state.hovered();
+        let drag_position = if state.hovered() {
-        let drag_position = cx
+            cx.global::<DragAndDrop<Workspace>>()
-            .global::<DragAndDrop<Workspace>>()
                 .currently_dragged::<DraggedItem>(cx.window_id())
-            .filter(|_| hovered)
+                .map(|(drag_position, _)| drag_position)
-            .map(|(drag_position, _)| drag_position);
+                .or_else(|| {
+                    cx.global::<DragAndDrop<Workspace>>()
+                        .currently_dragged::<DraggedProjectEntry>(cx.window_id())
+                        .map(|(drag_position, _)| drag_position)
+                })
+        } else {
+            None
+        };
 
         Stack::new()
             .with_child(render_child(state, cx))
@@ -70,10 +76,14 @@ where
         }
     })
     .on_move(|_, cx| {
-        if cx
+        let drag_and_drop = cx.global::<DragAndDrop<Workspace>>();
-            .global::<DragAndDrop<Workspace>>()
+
+        if drag_and_drop
             .currently_dragged::<DraggedItem>(cx.window_id())
             .is_some()
+            || drag_and_drop
+                .currently_dragged::<DraggedProjectEntry>(cx.window_id())
+                .is_some()
         {
             cx.notify();
         } else {