Move all crates to a top-level crates folder

Co-Authored-By: Max Brunsfeld <maxbrunsfeld@gmail.com>

crates/gpui/src/elements/mouse_event_handler.rs

@@ -0,0 +1,208 @@
+use super::Padding;
+use crate::{
+    geometry::{
+        rect::RectF,
+        vector::{vec2f, Vector2F},
+    },
+    platform::CursorStyle,
+    CursorStyleHandle, DebugContext, Element, ElementBox, ElementStateHandle, ElementStateId,
+    Event, EventContext, LayoutContext, MutableAppContext, PaintContext, SizeConstraint,
+};
+use serde_json::json;
+use std::ops::DerefMut;
+
+pub struct MouseEventHandler {
+    state: ElementStateHandle<MouseState>,
+    child: ElementBox,
+    cursor_style: Option<CursorStyle>,
+    mouse_down_handler: Option<Box<dyn FnMut(&mut EventContext)>>,
+    click_handler: Option<Box<dyn FnMut(&mut EventContext)>>,
+    drag_handler: Option<Box<dyn FnMut(Vector2F, &mut EventContext)>>,
+    padding: Padding,
+}
+
+#[derive(Default)]
+pub struct MouseState {
+    pub hovered: bool,
+    pub clicked: bool,
+    prev_drag_position: Option<Vector2F>,
+    cursor_style_handle: Option<CursorStyleHandle>,
+}
+
+impl MouseEventHandler {
+    pub fn new<Tag, F, C, Id>(id: Id, cx: &mut C, render_child: F) -> Self
+    where
+        Tag: 'static,
+        F: FnOnce(&MouseState, &mut C) -> ElementBox,
+        C: DerefMut<Target = MutableAppContext>,
+        Id: Into<ElementStateId>,
+    {
+        let state_handle = cx.element_state::<Tag, _>(id.into());
+        let child = state_handle.update(cx, |state, cx| render_child(state, cx));
+        Self {
+            state: state_handle,
+            child,
+            cursor_style: None,
+            mouse_down_handler: None,
+            click_handler: None,
+            drag_handler: None,
+            padding: Default::default(),
+        }
+    }
+
+    pub fn with_cursor_style(mut self, cursor: CursorStyle) -> Self {
+        self.cursor_style = Some(cursor);
+        self
+    }
+
+    pub fn on_mouse_down(mut self, handler: impl FnMut(&mut EventContext) + 'static) -> Self {
+        self.mouse_down_handler = Some(Box::new(handler));
+        self
+    }
+
+    pub fn on_click(mut self, handler: impl FnMut(&mut EventContext) + 'static) -> Self {
+        self.click_handler = Some(Box::new(handler));
+        self
+    }
+
+    pub fn on_drag(mut self, handler: impl FnMut(Vector2F, &mut EventContext) + 'static) -> Self {
+        self.drag_handler = Some(Box::new(handler));
+        self
+    }
+
+    pub fn with_padding(mut self, padding: Padding) -> Self {
+        self.padding = padding;
+        self
+    }
+}
+
+impl Element for MouseEventHandler {
+    type LayoutState = ();
+    type PaintState = ();
+
+    fn layout(
+        &mut self,
+        constraint: SizeConstraint,
+        cx: &mut LayoutContext,
+    ) -> (Vector2F, Self::LayoutState) {
+        (self.child.layout(constraint, cx), ())
+    }
+
+    fn paint(
+        &mut self,
+        bounds: RectF,
+        visible_bounds: RectF,
+        _: &mut Self::LayoutState,
+        cx: &mut PaintContext,
+    ) -> Self::PaintState {
+        self.child.paint(bounds.origin(), visible_bounds, cx);
+    }
+
+    fn dispatch_event(
+        &mut self,
+        event: &Event,
+        bounds: RectF,
+        _: &mut Self::LayoutState,
+        _: &mut Self::PaintState,
+        cx: &mut EventContext,
+    ) -> bool {
+        let cursor_style = self.cursor_style;
+        let mouse_down_handler = self.mouse_down_handler.as_mut();
+        let click_handler = self.click_handler.as_mut();
+        let drag_handler = self.drag_handler.as_mut();
+
+        let handled_in_child = self.child.dispatch_event(event, cx);
+
+        let hit_bounds = RectF::from_points(
+            bounds.origin() - vec2f(self.padding.left, self.padding.top),
+            bounds.lower_right() + vec2f(self.padding.right, self.padding.bottom),
+        )
+        .round_out();
+
+        self.state.update(cx, |state, cx| match event {
+            Event::MouseMoved {
+                position,
+                left_mouse_down,
+            } => {
+                if !left_mouse_down {
+                    let mouse_in = hit_bounds.contains_point(*position);
+                    if state.hovered != mouse_in {
+                        state.hovered = mouse_in;
+                        if let Some(cursor_style) = cursor_style {
+                            if !state.clicked {
+                                if state.hovered {
+                                    state.cursor_style_handle =
+                                        Some(cx.set_cursor_style(cursor_style));
+                                } else {
+                                    state.cursor_style_handle = None;
+                                }
+                            }
+                        }
+                        cx.notify();
+                        return true;
+                    }
+                }
+                handled_in_child
+            }
+            Event::LeftMouseDown { position, .. } => {
+                if !handled_in_child && hit_bounds.contains_point(*position) {
+                    state.clicked = true;
+                    state.prev_drag_position = Some(*position);
+                    cx.notify();
+                    if let Some(handler) = mouse_down_handler {
+                        handler(cx);
+                    }
+                    true
+                } else {
+                    handled_in_child
+                }
+            }
+            Event::LeftMouseUp { position, .. } => {
+                state.prev_drag_position = None;
+                if !handled_in_child && state.clicked {
+                    state.clicked = false;
+                    if !state.hovered {
+                        state.cursor_style_handle = None;
+                    }
+                    cx.notify();
+                    if let Some(handler) = click_handler {
+                        if hit_bounds.contains_point(*position) {
+                            handler(cx);
+                        }
+                    }
+                    true
+                } else {
+                    handled_in_child
+                }
+            }
+            Event::LeftMouseDragged { position, .. } => {
+                if !handled_in_child && state.clicked {
+                    let prev_drag_position = state.prev_drag_position.replace(*position);
+                    if let Some((handler, prev_position)) = drag_handler.zip(prev_drag_position) {
+                        let delta = *position - prev_position;
+                        if !delta.is_zero() {
+                            (handler)(delta, cx);
+                        }
+                    }
+                    true
+                } else {
+                    handled_in_child
+                }
+            }
+            _ => handled_in_child,
+        })
+    }
+
+    fn debug(
+        &self,
+        _: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        cx: &DebugContext,
+    ) -> serde_json::Value {
+        json!({
+            "type": "MouseEventHandler",
+            "child": self.child.debug(cx),
+        })
+    }
+}