Merge remote-tracking branch 'origin/master' into feat/multi-window-support

# Conflicts:
#	Cargo.toml
#	core/src/window/icon.rs
#	core/src/window/id.rs
#	core/src/window/position.rs
#	core/src/window/settings.rs
#	examples/integration/src/main.rs
#	examples/integration_opengl/src/main.rs
#	glutin/src/application.rs
#	native/src/subscription.rs
#	native/src/window.rs
#	runtime/src/window/action.rs
#	src/lib.rs
#	src/window.rs
#	winit/Cargo.toml
#	winit/src/application.rs
#	winit/src/icon.rs
#	winit/src/settings.rs
#	winit/src/window.rs

1 files changed, 123 insertions, 101 deletions

diff --git a/native/src/user_interface.rs b/runtime/src/user_interface.rs
index 68ccda55..619423fd 100644
--- a/native/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -1,14 +1,12 @@
 //! Implement your own event loop to drive a user interface.
-use crate::application;
-use crate::event::{self, Event};
-use crate::layout;
-use crate::mouse;
-use crate::renderer;
-use crate::widget;
-use crate::window;
-use crate::{
-    Clipboard, Element, Layout, Point, Rectangle, Shell, Size, Vector,
-};
+use crate::core::event::{self, Event};
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::renderer;
+use crate::core::widget;
+use crate::core::window;
+use crate::core::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size};
+use crate::overlay;
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
@@ -18,11 +16,10 @@ use crate::{
 /// charge of using this type in your system in any way you want.
 ///
 /// # Example
-/// The [`integration_opengl`] & [`integration_wgpu`] examples use a
-/// [`UserInterface`] to integrate Iced in an existing graphical application.
+/// The [`integration`] example uses a [`UserInterface`] to integrate Iced in an
+/// existing graphical application.
 ///
-/// [`integration_opengl`]: https://github.com/iced-rs/iced/tree/0.8/examples/integration_opengl
-/// [`integration_wgpu`]: https://github.com/iced-rs/iced/tree/0.8/examples/integration_wgpu
+/// [`integration`]: https://github.com/iced-rs/iced/tree/0.9/examples/integration
 #[allow(missing_debug_implementations)]
 pub struct UserInterface<'a, Message, Renderer> {
     root: Element<'a, Message, Renderer>,
@@ -34,8 +31,7 @@ pub struct UserInterface<'a, Message, Renderer> {
 
 impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>
 where
-    Renderer: crate::Renderer,
-    Renderer::Theme: application::StyleSheet,
+    Renderer: crate::core::Renderer,
 {
     /// Builds a user interface for an [`Element`].
     ///
@@ -48,24 +44,21 @@ where
     /// is naive way to set up our application loop:
     ///
     /// ```no_run
-    /// use iced_native::Size;
-    /// use iced_native::user_interface::{self, UserInterface};
-    /// use iced_wgpu::Renderer;
-    ///
     /// # mod iced_wgpu {
-    /// #     pub use iced_native::renderer::Null as Renderer;
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
     /// # }
     /// #
-    /// # use iced_native::widget::Column;
-    /// #
     /// # pub struct Counter;
     /// #
     /// # impl Counter {
     /// #     pub fn new() -> Self { Counter }
-    /// #     pub fn view(&self) -> Column<(), Renderer> {
-    /// #         Column::new()
-    /// #     }
+    /// #     pub fn view(&self) -> iced_core::Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
     /// # }
+    /// use iced_runtime::core::Size;
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::Renderer;
+    ///
     /// // Initialization
     /// let mut counter = Counter::new();
     /// let mut cache = user_interface::Cache::new();
@@ -124,30 +117,28 @@ where
     /// completing [the previous example](#example):
     ///
     /// ```no_run
-    /// use iced_native::{clipboard, Size, Point};
-    /// use iced_native::user_interface::{self, UserInterface};
-    /// use iced_wgpu::Renderer;
-    ///
     /// # mod iced_wgpu {
-    /// #     pub use iced_native::renderer::Null as Renderer;
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
     /// # }
     /// #
-    /// # use iced_native::widget::Column;
-    /// #
     /// # pub struct Counter;
     /// #
     /// # impl Counter {
     /// #     pub fn new() -> Self { Counter }
-    /// #     pub fn view(&self) -> Column<(), Renderer> {
-    /// #         Column::new()
-    /// #     }
-    /// #     pub fn update(&mut self, message: ()) {}
+    /// #     pub fn view(&self) -> iced_core::Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
     /// # }
+    /// use iced_runtime::core::clipboard;
+    /// use iced_runtime::core::mouse;
+    /// use iced_runtime::core::Size;
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::Renderer;
+    ///
     /// let mut counter = Counter::new();
     /// let mut cache = user_interface::Cache::new();
     /// let mut renderer = Renderer::new();
     /// let mut window_size = Size::new(1024.0, 768.0);
-    /// let mut cursor_position = Point::default();
+    /// let mut cursor = mouse::Cursor::default();
     /// let mut clipboard = clipboard::Null;
     ///
     /// // Initialize our event storage
@@ -167,7 +158,7 @@ where
     ///     // Update the user interface
     ///     let (state, event_statuses) = user_interface.update(
     ///         &events,
-    ///         cursor_position,
+    ///         cursor,
     ///         &mut renderer,
     ///         &mut clipboard,
     ///         &mut messages
@@ -184,7 +175,7 @@ where
     pub fn update(
         &mut self,
         events: &[Event],
-        cursor_position: Point,
+        cursor: mouse::Cursor,
         renderer: &mut Renderer,
         clipboard: &mut dyn Clipboard,
         messages: &mut Vec<Message>,
@@ -194,18 +185,18 @@ where
         let mut outdated = false;
         let mut redraw_request = None;
 
-        let mut manual_overlay =
-            ManuallyDrop::new(self.root.as_widget_mut().overlay(
-                &mut self.state,
-                Layout::new(&self.base),
-                renderer,
-            ));
+        let mut manual_overlay = ManuallyDrop::new(
+            self.root
+                .as_widget_mut()
+                .overlay(&mut self.state, Layout::new(&self.base), renderer)
+                .map(overlay::Nested::new),
+        );
 
         let (base_cursor, overlay_statuses) = if manual_overlay.is_some() {
             let bounds = self.bounds;
 
             let mut overlay = manual_overlay.as_mut().unwrap();
-            let mut layout = overlay.layout(renderer, bounds, Vector::ZERO);
+            let mut layout = overlay.layout(renderer, bounds, Point::ORIGIN);
             let mut event_statuses = Vec::new();
 
             for event in events.iter().cloned() {
@@ -214,7 +205,7 @@ where
                 let event_status = overlay.on_event(
                     event,
                     Layout::new(&layout),
-                    cursor_position,
+                    cursor,
                     renderer,
                     clipboard,
                     &mut shell,
@@ -240,12 +231,16 @@ where
                         &layout::Limits::new(Size::ZERO, self.bounds),
                     );
 
-                    manual_overlay =
-                        ManuallyDrop::new(self.root.as_widget_mut().overlay(
-                            &mut self.state,
-                            Layout::new(&self.base),
-                            renderer,
-                        ));
+                    manual_overlay = ManuallyDrop::new(
+                        self.root
+                            .as_widget_mut()
+                            .overlay(
+                                &mut self.state,
+                                Layout::new(&self.base),
+                                renderer,
+                            )
+                            .map(overlay::Nested::new),
+                    );
 
                     if manual_overlay.is_none() {
                         break;
@@ -254,7 +249,8 @@ where
                     overlay = manual_overlay.as_mut().unwrap();
 
                     shell.revalidate_layout(|| {
-                        layout = overlay.layout(renderer, bounds, Vector::ZERO);
+                        layout =
+                            overlay.layout(renderer, bounds, Point::ORIGIN);
                     });
                 }
 
@@ -263,22 +259,29 @@ where
                 }
             }
 
-            let base_cursor = manual_overlay
-                .as_ref()
-                .filter(|overlay| {
-                    overlay.is_over(Layout::new(&layout), cursor_position)
-                })
-                .map(|_| {
-                    // TODO: Type-safe cursor availability
-                    Point::new(-1.0, -1.0)
+            let base_cursor = if manual_overlay
+                .as_mut()
+                .and_then(|overlay| {
+                    cursor.position().map(|cursor_position| {
+                        overlay.is_over(
+                            Layout::new(&layout),
+                            renderer,
+                            cursor_position,
+                        )
+                    })
                 })
-                .unwrap_or(cursor_position);
+                .unwrap_or_default()
+            {
+                mouse::Cursor::Unavailable
+            } else {
+                cursor
+            };
 
             self.overlay = Some(layout);
 
             (base_cursor, event_statuses)
         } else {
-            (cursor_position, vec![event::Status::Ignored; events.len()])
+            (cursor, vec![event::Status::Ignored; events.len()])
         };
 
         let _ = ManuallyDrop::into_inner(manual_overlay);
@@ -357,35 +360,34 @@ where
     /// [completing the last example](#example-1):
     ///
     /// ```no_run
-    /// use iced_native::clipboard;
-    /// use iced_native::renderer;
-    /// use iced_native::user_interface::{self, UserInterface};
-    /// use iced_native::{Size, Point, Theme};
-    /// use iced_wgpu::Renderer;
-    ///
     /// # mod iced_wgpu {
-    /// #     pub use iced_native::renderer::Null as Renderer;
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
+    /// #     pub type Theme = ();
     /// # }
     /// #
-    /// # use iced_native::widget::Column;
-    /// #
     /// # pub struct Counter;
     /// #
     /// # impl Counter {
     /// #     pub fn new() -> Self { Counter }
-    /// #     pub fn view(&self) -> Column<(), Renderer> {
-    /// #         Column::new()
-    /// #     }
-    /// #     pub fn update(&mut self, message: ()) {}
+    /// #     pub fn view(&self) -> Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
     /// # }
+    /// use iced_runtime::core::clipboard;
+    /// use iced_runtime::core::mouse;
+    /// use iced_runtime::core::renderer;
+    /// use iced_runtime::core::{Element, Size};
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::{Renderer, Theme};
+    ///
     /// let mut counter = Counter::new();
     /// let mut cache = user_interface::Cache::new();
     /// let mut renderer = Renderer::new();
     /// let mut window_size = Size::new(1024.0, 768.0);
-    /// let mut cursor_position = Point::default();
+    /// let mut cursor = mouse::Cursor::default();
     /// let mut clipboard = clipboard::Null;
     /// let mut events = Vec::new();
     /// let mut messages = Vec::new();
+    /// let mut theme = Theme::default();
     ///
     /// loop {
     ///     // Obtain system events...
@@ -400,14 +402,14 @@ where
     ///     // Update the user interface
     ///     let event_statuses = user_interface.update(
     ///         &events,
-    ///         cursor_position,
+    ///         cursor,
     ///         &mut renderer,
     ///         &mut clipboard,
     ///         &mut messages
     ///     );
     ///
     ///     // Draw the user interface
-    ///     let mouse_cursor = user_interface.draw(&mut renderer, &Theme::default(), &renderer::Style::default(), cursor_position);
+    ///     let mouse_interaction = user_interface.draw(&mut renderer, &theme, &renderer::Style::default(), cursor);
     ///
     ///     cache = user_interface.into_cache();
     ///
@@ -424,35 +426,44 @@ where
         renderer: &mut Renderer,
         theme: &Renderer::Theme,
         style: &renderer::Style,
-        cursor_position: Point,
+        cursor: mouse::Cursor,
     ) -> mouse::Interaction {
         // TODO: Move to shell level (?)
         renderer.clear();
 
         let viewport = Rectangle::with_size(self.bounds);
 
-        let base_cursor = if let Some(overlay) = self
+        let base_cursor = if let Some(mut overlay) = self
             .root
             .as_widget_mut()
             .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
         {
             let overlay_layout = self.overlay.take().unwrap_or_else(|| {
-                overlay.layout(renderer, self.bounds, Vector::ZERO)
+                overlay.layout(renderer, self.bounds, Point::ORIGIN)
             });
 
-            let new_cursor_position = if overlay
-                .is_over(Layout::new(&overlay_layout), cursor_position)
+            let cursor = if cursor
+                .position()
+                .map(|cursor_position| {
+                    overlay.is_over(
+                        Layout::new(&overlay_layout),
+                        renderer,
+                        cursor_position,
+                    )
+                })
+                .unwrap_or_default()
             {
-                Point::new(-1.0, -1.0)
+                mouse::Cursor::Unavailable
             } else {
-                cursor_position
+                cursor
             };
 
             self.overlay = Some(overlay_layout);
 
-            new_cursor_position
+            cursor
         } else {
-            cursor_position
+            cursor
         };
 
         self.root.as_widget().draw(
@@ -468,7 +479,7 @@ where
         let base_interaction = self.root.as_widget().mouse_interaction(
             &self.state,
             Layout::new(&self.base),
-            cursor_position,
+            base_cursor,
             &viewport,
             renderer,
         );
@@ -490,10 +501,11 @@ where
             .and_then(|layout| {
                 root.as_widget_mut()
                     .overlay(&mut self.state, Layout::new(base), renderer)
-                    .map(|overlay| {
+                    .map(overlay::Nested::new)
+                    .map(|mut overlay| {
                         let overlay_interaction = overlay.mouse_interaction(
                             Layout::new(layout),
-                            cursor_position,
+                            cursor,
                             &viewport,
                             renderer,
                         );
@@ -506,11 +518,20 @@ where
                                 theme,
                                 style,
                                 Layout::new(layout),
-                                cursor_position,
+                                cursor,
                             );
                         });
 
-                        if overlay.is_over(Layout::new(layout), cursor_position)
+                        if cursor
+                            .position()
+                            .map(|cursor_position| {
+                                overlay.is_over(
+                                    Layout::new(layout),
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default()
                         {
                             overlay_interaction
                         } else {
@@ -534,14 +555,15 @@ where
             operation,
         );
 
-        if let Some(mut overlay) = self.root.as_widget_mut().overlay(
-            &mut self.state,
-            Layout::new(&self.base),
-            renderer,
-        ) {
+        if let Some(mut overlay) = self
+            .root
+            .as_widget_mut()
+            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
+        {
             if self.overlay.is_none() {
                 self.overlay =
-                    Some(overlay.layout(renderer, self.bounds, Vector::ZERO));
+                    Some(overlay.layout(renderer, self.bounds, Point::ORIGIN));
             }
 
             overlay.operate(