Create `iced_widget` subcrate and re-organize the whole codebase

24 files changed, 143 insertions, 163 deletions

diff --git a/examples/component/Cargo.toml b/examples/component/Cargo.toml
index dd435201..9db1e6b4 100644
--- a/examples/component/Cargo.toml
+++ b/examples/component/Cargo.toml
@@ -6,6 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["debug"] }
-iced_native = { path = "../../native" }
-iced_lazy = { path = "../../lazy" }
+iced = { path = "../..", features = ["debug", "lazy"] }
diff --git a/examples/component/src/main.rs b/examples/component/src/main.rs
index c407bb06..e59588b1 100644
--- a/examples/component/src/main.rs
+++ b/examples/component/src/main.rs
@@ -47,9 +47,8 @@ impl Sandbox for Component {
 
 mod numeric_input {
     use iced::alignment::{self, Alignment};
-    use iced::widget::{self, button, row, text, text_input};
-    use iced::{Element, Length};
-    use iced_lazy::{self, Component};
+    use iced::widget::{button, component, row, text, text_input, Component};
+    use iced::{Element, Length, Renderer};
 
     pub struct NumericInput<Message> {
         value: Option<u32>,
@@ -82,13 +81,7 @@ mod numeric_input {
         }
     }
 
-    impl<Message, Renderer> Component<Message, Renderer> for NumericInput<Message>
-    where
-        Renderer: iced_native::text::Renderer + 'static,
-        Renderer::Theme: widget::button::StyleSheet
-            + widget::text_input::StyleSheet
-            + widget::text::StyleSheet,
-    {
+    impl<Message> Component<Message, Renderer> for NumericInput<Message> {
         type State = ();
         type Event = Event;
 
@@ -151,17 +144,12 @@ mod numeric_input {
         }
     }
 
-    impl<'a, Message, Renderer> From<NumericInput<Message>>
-        for Element<'a, Message, Renderer>
+    impl<'a, Message> From<NumericInput<Message>> for Element<'a, Message, Renderer>
     where
         Message: 'a,
-        Renderer: 'static + iced_native::text::Renderer,
-        Renderer::Theme: widget::button::StyleSheet
-            + widget::text_input::StyleSheet
-            + widget::text::StyleSheet,
     {
         fn from(numeric_input: NumericInput<Message>) -> Self {
-            iced_lazy::component(numeric_input)
+            component(numeric_input)
         }
     }
 }
diff --git a/examples/custom_quad/Cargo.toml b/examples/custom_quad/Cargo.toml
index 39154786..f097c2dd 100644
--- a/examples/custom_quad/Cargo.toml
+++ b/examples/custom_quad/Cargo.toml
@@ -6,5 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../.." }
-iced_native = { path = "../../native" }
+iced = { path = "../..", features = ["advanced"] }
diff --git a/examples/custom_quad/src/main.rs b/examples/custom_quad/src/main.rs
index 6509887c..b07f42ce 100644
--- a/examples/custom_quad/src/main.rs
+++ b/examples/custom_quad/src/main.rs
@@ -1,9 +1,9 @@
 //! This example showcases a drawing a quad.
 mod quad {
-    use iced_native::layout::{self, Layout};
-    use iced_native::renderer;
-    use iced_native::widget::{self, Widget};
-    use iced_native::{Color, Element, Length, Point, Rectangle, Size};
+    use iced::advanced::layout::{self, Layout};
+    use iced::advanced::renderer;
+    use iced::advanced::widget::{self, Widget};
+    use iced::{Color, Element, Length, Point, Rectangle, Size};
 
     pub struct CustomQuad {
         size: f32,
diff --git a/examples/custom_widget/Cargo.toml b/examples/custom_widget/Cargo.toml
index 067aab4a..dda0efe8 100644
--- a/examples/custom_widget/Cargo.toml
+++ b/examples/custom_widget/Cargo.toml
@@ -6,5 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../.." }
-iced_native = { path = "../../native" }
+iced = { path = "../..", features = ["advanced"] }
diff --git a/examples/custom_widget/src/main.rs b/examples/custom_widget/src/main.rs
index f6bb3b1e..7854548c 100644
--- a/examples/custom_widget/src/main.rs
+++ b/examples/custom_widget/src/main.rs
@@ -9,10 +9,10 @@ mod circle {
     // Of course, you can choose to make the implementation renderer-agnostic,
     // if you wish to, by creating your own `Renderer` trait, which could be
     // implemented by `iced_wgpu` and other renderers.
-    use iced_native::layout::{self, Layout};
-    use iced_native::renderer;
-    use iced_native::widget::{self, Widget};
-    use iced_native::{Color, Element, Length, Point, Rectangle, Size};
+    use iced::advanced::layout::{self, Layout};
+    use iced::advanced::renderer;
+    use iced::advanced::widget::{self, Widget};
+    use iced::{Color, Element, Length, Point, Rectangle, Size};
 
     pub struct Circle {
         radius: f32,
diff --git a/examples/events/Cargo.toml b/examples/events/Cargo.toml
index 8c56e471..15ffc0af 100644
--- a/examples/events/Cargo.toml
+++ b/examples/events/Cargo.toml
@@ -7,4 +7,3 @@ publish = false
 
 [dependencies]
 iced = { path = "../..", features = ["debug"] }
-iced_native = { path = "../../native" }
diff --git a/examples/events/src/main.rs b/examples/events/src/main.rs
index 1b97018e..7f3a5e1d 100644
--- a/examples/events/src/main.rs
+++ b/examples/events/src/main.rs
@@ -1,12 +1,13 @@
 use iced::alignment;
 use iced::executor;
+use iced::subscription;
 use iced::widget::{button, checkbox, container, text, Column};
 use iced::window;
+use iced::Event;
 use iced::{
     Alignment, Application, Command, Element, Length, Settings, Subscription,
     Theme,
 };
-use iced_native::Event;
 
 pub fn main() -> iced::Result {
     Events::run(Settings {
@@ -17,13 +18,13 @@ pub fn main() -> iced::Result {
 
 #[derive(Debug, Default)]
 struct Events {
-    last: Vec<iced_native::Event>,
+    last: Vec<Event>,
     enabled: bool,
 }
 
 #[derive(Debug, Clone)]
 enum Message {
-    EventOccurred(iced_native::Event),
+    EventOccurred(Event),
     Toggled(bool),
     Exit,
 }
@@ -70,7 +71,7 @@ impl Application for Events {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        iced_native::subscription::events().map(Message::EventOccurred)
+        subscription::events().map(Message::EventOccurred)
     }
 
     fn view(&self) -> Element<Message> {
diff --git a/examples/geometry/Cargo.toml b/examples/geometry/Cargo.toml
index 22ede0e0..79fe52d5 100644
--- a/examples/geometry/Cargo.toml
+++ b/examples/geometry/Cargo.toml
@@ -6,6 +6,5 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../.." }
-iced_native = { path = "../../native" }
+iced = { path = "../..", features = ["advanced"] }
 iced_graphics = { path = "../../graphics" }
diff --git a/examples/geometry/src/main.rs b/examples/geometry/src/main.rs
index a77772d5..5cb41184 100644
--- a/examples/geometry/src/main.rs
+++ b/examples/geometry/src/main.rs
@@ -1,23 +1,13 @@
 //! This example showcases a simple native custom widget that renders using
 //! arbitrary low-level geometry.
 mod rainbow {
-    // For now, to implement a custom native widget you will need to add
-    // `iced_native` and `iced_wgpu` to your dependencies.
-    //
-    // Then, you simply need to define your widget type and implement the
-    // `iced_native::Widget` trait with the `iced_wgpu::Renderer`.
-    //
-    // Of course, you can choose to make the implementation renderer-agnostic,
-    // if you wish to, by creating your own `Renderer` trait, which could be
-    // implemented by `iced_wgpu` and other renderers.
     use iced_graphics::primitive::{ColoredVertex2D, Primitive};
-    use iced_graphics::renderer::{self, Renderer};
-    use iced_graphics::Backend;
 
-    use iced_native::layout;
-    use iced_native::widget::{self, Widget};
-    use iced_native::{
-        Element, Layout, Length, Point, Rectangle, Size, Vector,
+    use iced::advanced::layout::{self, Layout};
+    use iced::advanced::renderer;
+    use iced::advanced::widget::{self, Widget};
+    use iced::{
+        Element, Length, Point, Rectangle, Renderer, Size, Theme, Vector,
     };
 
     #[derive(Debug, Clone, Copy, Default)]
@@ -27,10 +17,7 @@ mod rainbow {
         Rainbow
     }
 
-    impl<Message, B, T> Widget<Message, Renderer<B, T>> for Rainbow
-    where
-        B: Backend,
-    {
+    impl<Message> Widget<Message, Renderer> for Rainbow {
         fn width(&self) -> Length {
             Length::Fill
         }
@@ -41,7 +28,7 @@ mod rainbow {
 
         fn layout(
             &self,
-            _renderer: &Renderer<B, T>,
+            _renderer: &Renderer,
             limits: &layout::Limits,
         ) -> layout::Node {
             let size = limits.width(Length::Fill).resolve(Size::ZERO);
@@ -52,15 +39,15 @@ mod rainbow {
         fn draw(
             &self,
             _tree: &widget::Tree,
-            renderer: &mut Renderer<B, T>,
-            _theme: &T,
+            renderer: &mut Renderer,
+            _theme: &Theme,
             _style: &renderer::Style,
             layout: Layout<'_>,
             cursor_position: Point,
             _viewport: &Rectangle,
         ) {
+            use iced::advanced::Renderer as _;
             use iced_graphics::primitive::Mesh2D;
-            use iced_native::Renderer as _;
 
             let b = layout.bounds();
 
@@ -151,10 +138,7 @@ mod rainbow {
         }
     }
 
-    impl<'a, Message, B, T> From<Rainbow> for Element<'a, Message, Renderer<B, T>>
-    where
-        B: Backend,
-    {
+    impl<'a, Message> From<Rainbow> for Element<'a, Message, Renderer> {
         fn from(rainbow: Rainbow) -> Self {
             Self::new(rainbow)
         }
diff --git a/examples/integration/Cargo.toml b/examples/integration/Cargo.toml
index 200306aa..60390242 100644
--- a/examples/integration/Cargo.toml
+++ b/examples/integration/Cargo.toml
@@ -8,6 +8,7 @@ publish = false
 [dependencies]
 iced_winit = { path = "../../winit" }
 iced_wgpu = { path = "../../wgpu", features = ["webgl"] }
+iced_widget = { path = "../../widget" }
 env_logger = "0.8"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
diff --git a/examples/integration/src/controls.rs b/examples/integration/src/controls.rs
index 533cb6e2..16e21709 100644
--- a/examples/integration/src/controls.rs
+++ b/examples/integration/src/controls.rs
@@ -1,6 +1,8 @@
 use iced_wgpu::Renderer;
-use iced_winit::widget::{slider, text_input, Column, Row, Text};
-use iced_winit::{Alignment, Color, Command, Element, Length, Program};
+use iced_widget::{slider, text_input, Column, Row, Text};
+use iced_winit::core::{Alignment, Color, Element, Length};
+use iced_winit::native::{Command, Program};
+use iced_winit::style::Theme;
 
 pub struct Controls {
     background_color: Color,
@@ -27,7 +29,7 @@ impl Controls {
 }
 
 impl Program for Controls {
-    type Renderer = Renderer;
+    type Renderer = Renderer<Theme>;
     type Message = Message;
 
     fn update(&mut self, message: Message) -> Command<Message> {
@@ -43,7 +45,7 @@ impl Program for Controls {
         Command::none()
     }
 
-    fn view(&self) -> Element<Message, Renderer> {
+    fn view(&self) -> Element<Message, Renderer<Theme>> {
         let background_color = self.background_color;
         let text = &self.text;
 
diff --git a/examples/integration/src/main.rs b/examples/integration/src/main.rs
index a7a90ced..c1f1f076 100644
--- a/examples/integration/src/main.rs
+++ b/examples/integration/src/main.rs
@@ -4,11 +4,14 @@ mod scene;
 use controls::Controls;
 use scene::Scene;
 
-use iced_wgpu::{wgpu, Backend, Renderer, Settings, Viewport};
-use iced_winit::{
-    conversion, futures, program, renderer, winit, Clipboard, Color, Debug,
-    Size,
-};
+use iced_wgpu::graphics::Viewport;
+use iced_wgpu::{wgpu, Backend, Renderer, Settings};
+use iced_winit::core::renderer;
+use iced_winit::core::{Color, Size};
+use iced_winit::native::program;
+use iced_winit::native::Debug;
+use iced_winit::style::Theme;
+use iced_winit::{conversion, futures, winit, Clipboard};
 
 use winit::{
     dpi::PhysicalPosition,
@@ -73,43 +76,45 @@ pub fn main() {
     let instance = wgpu::Instance::new(backend);
     let surface = unsafe { instance.create_surface(&window) };
 
-    let (format, (device, queue)) = futures::executor::block_on(async {
-        let adapter = wgpu::util::initialize_adapter_from_env_or_default(
-            &instance,
-            backend,
-            Some(&surface),
-        )
-        .await
-        .expect("No suitable GPU adapters found on the system!");
-
-        let adapter_features = adapter.features();
-
-        #[cfg(target_arch = "wasm32")]
-        let needed_limits = wgpu::Limits::downlevel_webgl2_defaults()
-            .using_resolution(adapter.limits());
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let needed_limits = wgpu::Limits::default();
-
-        (
-            surface
-                .get_supported_formats(&adapter)
-                .first()
-                .copied()
-                .expect("Get preferred format"),
-            adapter
-                .request_device(
-                    &wgpu::DeviceDescriptor {
-                        label: None,
-                        features: adapter_features & wgpu::Features::default(),
-                        limits: needed_limits,
-                    },
-                    None,
-                )
-                .await
-                .expect("Request device"),
-        )
-    });
+    let (format, (device, queue)) =
+        futures::futures::executor::block_on(async {
+            let adapter = wgpu::util::initialize_adapter_from_env_or_default(
+                &instance,
+                backend,
+                Some(&surface),
+            )
+            .await
+            .expect("No suitable GPU adapters found on the system!");
+
+            let adapter_features = adapter.features();
+
+            #[cfg(target_arch = "wasm32")]
+            let needed_limits = wgpu::Limits::downlevel_webgl2_defaults()
+                .using_resolution(adapter.limits());
+
+            #[cfg(not(target_arch = "wasm32"))]
+            let needed_limits = wgpu::Limits::default();
+
+            (
+                surface
+                    .get_supported_formats(&adapter)
+                    .first()
+                    .copied()
+                    .expect("Get preferred format"),
+                adapter
+                    .request_device(
+                        &wgpu::DeviceDescriptor {
+                            label: None,
+                            features: adapter_features
+                                & wgpu::Features::default(),
+                            limits: needed_limits,
+                        },
+                        None,
+                    )
+                    .await
+                    .expect("Request device"),
+            )
+        });
 
     surface.configure(
         &device,
@@ -188,7 +193,7 @@ pub fn main() {
                             viewport.scale_factor(),
                         ),
                         &mut renderer,
-                        &iced_wgpu::Theme::Dark,
+                        &Theme::Dark,
                         &renderer::Style { text_color: Color::WHITE },
                         &mut clipboard,
                         &mut debug,
diff --git a/examples/integration/src/scene.rs b/examples/integration/src/scene.rs
index 3e41fbda..90c7efbf 100644
--- a/examples/integration/src/scene.rs
+++ b/examples/integration/src/scene.rs
@@ -1,5 +1,5 @@
 use iced_wgpu::wgpu;
-use iced_winit::Color;
+use iced_winit::core::Color;
 
 pub struct Scene {
     pipeline: wgpu::RenderPipeline,
diff --git a/examples/lazy/Cargo.toml b/examples/lazy/Cargo.toml
index 79255c25..e03e89a9 100644
--- a/examples/lazy/Cargo.toml
+++ b/examples/lazy/Cargo.toml
@@ -6,5 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["debug"] }
-iced_lazy = { path = "../../lazy" }
+iced = { path = "../..", features = ["debug", "lazy"] }
diff --git a/examples/lazy/src/main.rs b/examples/lazy/src/main.rs
index 6512106f..e1cdaefe 100644
--- a/examples/lazy/src/main.rs
+++ b/examples/lazy/src/main.rs
@@ -1,10 +1,9 @@
 use iced::theme;
 use iced::widget::{
-    button, column, horizontal_space, pick_list, row, scrollable, text,
+    button, column, horizontal_space, lazy, pick_list, row, scrollable, text,
     text_input,
 };
 use iced::{Element, Length, Sandbox, Settings};
-use iced_lazy::lazy;
 
 use std::collections::HashSet;
 use std::hash::Hash;
diff --git a/examples/modal/Cargo.toml b/examples/modal/Cargo.toml
index 8770acac..3ac61e6a 100644
--- a/examples/modal/Cargo.toml
+++ b/examples/modal/Cargo.toml
@@ -6,5 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = [] }
-iced_native = { path = "../../native" }
+iced = { path = "../..", features = ["advanced"] }
diff --git a/examples/modal/src/main.rs b/examples/modal/src/main.rs
index 54555684..214ec97e 100644
--- a/examples/modal/src/main.rs
+++ b/examples/modal/src/main.rs
@@ -178,12 +178,15 @@ impl App {
 }
 
 mod modal {
-    use iced_native::alignment::Alignment;
-    use iced_native::widget::{self, Tree};
-    use iced_native::{
-        event, layout, mouse, overlay, renderer, Clipboard, Color, Element,
-        Event, Layout, Length, Point, Rectangle, Shell, Size, Widget,
-    };
+    use iced::advanced::layout::{self, Layout};
+    use iced::advanced::overlay;
+    use iced::advanced::renderer;
+    use iced::advanced::widget::{self, Widget};
+    use iced::advanced::{self, Clipboard, Shell};
+    use iced::alignment::Alignment;
+    use iced::event;
+    use iced::mouse;
+    use iced::{Color, Element, Event, Length, Point, Rectangle, Size};
 
     /// A widget that centers a modal element over some base element
     pub struct Modal<'a, Message, Renderer> {
@@ -218,14 +221,17 @@ mod modal {
     impl<'a, Message, Renderer> Widget<Message, Renderer>
         for Modal<'a, Message, Renderer>
     where
-        Renderer: iced_native::Renderer,
+        Renderer: advanced::Renderer,
         Message: Clone,
     {
-        fn children(&self) -> Vec<Tree> {
-            vec![Tree::new(&self.base), Tree::new(&self.modal)]
+        fn children(&self) -> Vec<widget::Tree> {
+            vec![
+                widget::Tree::new(&self.base),
+                widget::Tree::new(&self.modal),
+            ]
         }
 
-        fn diff(&self, tree: &mut Tree) {
+        fn diff(&self, tree: &mut widget::Tree) {
             tree.diff_children(&[&self.base, &self.modal]);
         }
 
@@ -247,7 +253,7 @@ mod modal {
 
         fn on_event(
             &mut self,
-            state: &mut Tree,
+            state: &mut widget::Tree,
             event: Event,
             layout: Layout<'_>,
             cursor_position: Point,
@@ -268,9 +274,9 @@ mod modal {
 
         fn draw(
             &self,
-            state: &Tree,
+            state: &widget::Tree,
             renderer: &mut Renderer,
-            theme: &<Renderer as iced_native::Renderer>::Theme,
+            theme: &<Renderer as advanced::Renderer>::Theme,
             style: &renderer::Style,
             layout: Layout<'_>,
             cursor_position: Point,
@@ -289,7 +295,7 @@ mod modal {
 
         fn overlay<'b>(
             &'b mut self,
-            state: &'b mut Tree,
+            state: &'b mut widget::Tree,
             layout: Layout<'_>,
             _renderer: &Renderer,
         ) -> Option<overlay::Element<'b, Message, Renderer>> {
@@ -306,7 +312,7 @@ mod modal {
 
         fn mouse_interaction(
             &self,
-            state: &Tree,
+            state: &widget::Tree,
             layout: Layout<'_>,
             cursor_position: Point,
             viewport: &Rectangle,
@@ -323,7 +329,7 @@ mod modal {
 
         fn operate(
             &self,
-            state: &mut Tree,
+            state: &mut widget::Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
             operation: &mut dyn widget::Operation<Message>,
@@ -339,7 +345,7 @@ mod modal {
 
     struct Overlay<'a, 'b, Message, Renderer> {
         content: &'b mut Element<'a, Message, Renderer>,
-        tree: &'b mut Tree,
+        tree: &'b mut widget::Tree,
         size: Size,
         on_blur: Option<Message>,
     }
@@ -347,7 +353,7 @@ mod modal {
     impl<'a, 'b, Message, Renderer> overlay::Overlay<Message, Renderer>
         for Overlay<'a, 'b, Message, Renderer>
     where
-        Renderer: iced_native::Renderer,
+        Renderer: advanced::Renderer,
         Message: Clone,
     {
         fn layout(
@@ -469,7 +475,7 @@ mod modal {
     impl<'a, Message, Renderer> From<Modal<'a, Message, Renderer>>
         for Element<'a, Message, Renderer>
     where
-        Renderer: 'a + iced_native::Renderer,
+        Renderer: 'a + advanced::Renderer,
         Message: 'a + Clone,
     {
         fn from(modal: Modal<'a, Message, Renderer>) -> Self {
diff --git a/examples/pane_grid/Cargo.toml b/examples/pane_grid/Cargo.toml
index dfd6dfa9..4c0bf072 100644
--- a/examples/pane_grid/Cargo.toml
+++ b/examples/pane_grid/Cargo.toml
@@ -6,6 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["debug"] }
-iced_native = { path = "../../native" }
-iced_lazy = { path = "../../lazy" }
+iced = { path = "../..", features = ["debug", "lazy"] }
diff --git a/examples/pane_grid/src/main.rs b/examples/pane_grid/src/main.rs
index c9f1376c..dfb80853 100644
--- a/examples/pane_grid/src/main.rs
+++ b/examples/pane_grid/src/main.rs
@@ -1,14 +1,16 @@
 use iced::alignment::{self, Alignment};
+use iced::event::{self, Event};
 use iced::executor;
 use iced::keyboard;
+use iced::subscription;
 use iced::theme::{self, Theme};
 use iced::widget::pane_grid::{self, PaneGrid};
-use iced::widget::{button, column, container, row, scrollable, text};
+use iced::widget::{
+    button, column, container, responsive, row, scrollable, text,
+};
 use iced::{
     Application, Color, Command, Element, Length, Settings, Size, Subscription,
 };
-use iced_lazy::responsive;
-use iced_native::{event, subscription, Event};
 
 pub fn main() -> iced::Result {
     Example::run(Settings::default())
diff --git a/examples/toast/Cargo.toml b/examples/toast/Cargo.toml
index f1f986aa..f703572c 100644
--- a/examples/toast/Cargo.toml
+++ b/examples/toast/Cargo.toml
@@ -6,5 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = [] }
-iced_native = { path = "../../native" }
+iced = { path = "../..", features = ["advanced"] }
diff --git a/examples/toast/src/main.rs b/examples/toast/src/main.rs
index e74b3ee6..78fb9de1 100644
--- a/examples/toast/src/main.rs
+++ b/examples/toast/src/main.rs
@@ -176,17 +176,23 @@ mod toast {
     use std::fmt;
     use std::time::{Duration, Instant};
 
+    use iced::advanced;
+    use iced::advanced::layout::{self, Layout};
+    use iced::advanced::overlay;
+    use iced::advanced::renderer;
+    use iced::advanced::widget::{self, Operation, Tree};
+    use iced::advanced::{Clipboard, Shell, Widget};
+    use iced::event::{self, Event};
+    use iced::mouse;
     use iced::theme;
     use iced::widget::{
         button, column, container, horizontal_rule, horizontal_space, row, text,
     };
+    use iced::window;
     use iced::{
         Alignment, Element, Length, Point, Rectangle, Renderer, Size, Theme,
         Vector,
     };
-    use iced_native::widget::{tree, Operation, Tree};
-    use iced_native::{event, layout, mouse, overlay, renderer, window};
-    use iced_native::{Clipboard, Event, Layout, Shell, Widget};
 
     pub const DEFAULT_TIMEOUT: u64 = 5;
 
@@ -324,13 +330,13 @@ mod toast {
             self.content.as_widget().layout(renderer, limits)
         }
 
-        fn tag(&self) -> tree::Tag {
+        fn tag(&self) -> widget::tree::Tag {
             struct Marker(Vec<Instant>);
-            iced_native::widget::tree::Tag::of::<Marker>()
+            widget::tree::Tag::of::<Marker>()
         }
 
-        fn state(&self) -> tree::State {
-            iced_native::widget::tree::State::new(Vec::<Option<Instant>>::new())
+        fn state(&self) -> widget::tree::State {
+            widget::tree::State::new(Vec::<Option<Instant>>::new())
         }
 
         fn children(&self) -> Vec<Tree> {
@@ -584,7 +590,7 @@ mod toast {
         fn draw(
             &self,
             renderer: &mut Renderer,
-            theme: &<Renderer as iced_native::Renderer>::Theme,
+            theme: &<Renderer as advanced::Renderer>::Theme,
             style: &renderer::Style,
             layout: Layout<'_>,
             cursor_position: Point,
@@ -613,7 +619,7 @@ mod toast {
             &mut self,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn iced_native::widget::Operation<Message>,
+            operation: &mut dyn widget::Operation<Message>,
         ) {
             operation.container(None, &mut |operation| {
                 self.toasts
diff --git a/examples/url_handler/Cargo.toml b/examples/url_handler/Cargo.toml
index 63c7ec27..4dcff92d 100644
--- a/examples/url_handler/Cargo.toml
+++ b/examples/url_handler/Cargo.toml
@@ -7,4 +7,3 @@ publish = false
 
 [dependencies]
 iced = { path = "../.." }
-iced_native = { path = "../../native" }
diff --git a/examples/url_handler/src/main.rs b/examples/url_handler/src/main.rs
index 3257b519..f63fa06a 100644
--- a/examples/url_handler/src/main.rs
+++ b/examples/url_handler/src/main.rs
@@ -1,12 +1,10 @@
+use iced::event::{Event, MacOS, PlatformSpecific};
 use iced::executor;
+use iced::subscription;
 use iced::widget::{container, text};
 use iced::{
     Application, Command, Element, Length, Settings, Subscription, Theme,
 };
-use iced_native::{
-    event::{MacOS, PlatformSpecific},
-    Event,
-};
 
 pub fn main() -> iced::Result {
     App::run(Settings::default())
@@ -19,7 +17,7 @@ struct App {
 
 #[derive(Debug, Clone)]
 enum Message {
-    EventOccurred(iced_native::Event),
+    EventOccurred(Event),
 }
 
 impl Application for App {
@@ -52,7 +50,7 @@ impl Application for App {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        iced_native::subscription::events().map(Message::EventOccurred)
+        subscription::events().map(Message::EventOccurred)
     }
 
     fn view(&self) -> Element<Message> {