Cursor availability during on_event

1 files changed, 50 insertions, 23 deletions

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 24ddb649..1211d55b 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -174,42 +174,67 @@ where
             renderer: &Renderer,
             clipboard: &mut dyn Clipboard,
             shell: &mut Shell<'_, Message>,
-        ) -> event::Status
+        ) -> (event::Status, bool)
         where
             Renderer: renderer::Renderer,
         {
             let mut layouts = layout.children();
 
             if let Some(layout) = layouts.next() {
-                let status = if let Some((mut nested, nested_layout)) =
-                    element.overlay(layout, renderer).zip(layouts.next())
-                {
-                    recurse(
-                        &mut nested,
-                        nested_layout,
-                        event.clone(),
-                        cursor,
-                        renderer,
-                        clipboard,
-                        shell,
-                    )
-                } else {
-                    event::Status::Ignored
-                };
+                let (nested_status, nested_is_over) =
+                    if let Some((mut nested, nested_layout)) =
+                        element.overlay(layout, renderer).zip(layouts.next())
+                    {
+                        recurse(
+                            &mut nested,
+                            nested_layout,
+                            event.clone(),
+                            cursor,
+                            renderer,
+                            clipboard,
+                            shell,
+                        )
+                    } else {
+                        (event::Status::Ignored, false)
+                    };
 
-                if matches!(status, event::Status::Ignored) {
-                    element.on_event(
-                        event, layout, cursor, renderer, clipboard, shell,
+                if matches!(nested_status, event::Status::Ignored) {
+                    let is_over = nested_is_over
+                        || cursor
+                            .position()
+                            .map(|cursor_position| {
+                                element.is_over(
+                                    layout,
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default();
+
+                    (
+                        element.on_event(
+                            event,
+                            layout,
+                            if nested_is_over {
+                                mouse::Cursor::Unavailable
+                            } else {
+                                cursor
+                            },
+                            renderer,
+                            clipboard,
+                            shell,
+                        ),
+                        is_over,
                     )
                 } else {
-                    status
+                    (nested_status, nested_is_over)
                 }
             } else {
-                event::Status::Ignored
+                (event::Status::Ignored, false)
             }
         }
 
-        recurse(
+        let (status, _) = recurse(
             &mut self.overlay,
             layout,
             event,
@@ -217,7 +242,9 @@ where
             renderer,
             clipboard,
             shell,
-        )
+        );
+
+        status
     }
 
     pub fn mouse_interaction(