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

19 files changed, 178 insertions, 375 deletions

diff --git a/src/advanced.rs b/src/advanced.rs
new file mode 100644
index 00000000..714076e0
--- /dev/null
+++ b/src/advanced.rs
@@ -0,0 +1,9 @@
+//! Leverage advanced concepts like custom widgets.
+pub use crate::core::image;
+pub use crate::core::layout::{self, Layout};
+pub use crate::core::overlay::{self, Overlay};
+pub use crate::core::renderer::{self, Renderer};
+pub use crate::core::svg;
+pub use crate::core::text::{self, Text};
+pub use crate::core::widget::{self, Widget};
+pub use crate::core::{Clipboard, Shell};
diff --git a/src/application.rs b/src/application.rs
index b9871556..f5cf3317 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -1,7 +1,7 @@
 //! Build interactive cross-platform applications.
 use crate::{Command, Element, Executor, Settings, Subscription};
 
-pub use iced_native::application::{Appearance, StyleSheet};
+pub use crate::style::application::{Appearance, StyleSheet};
 
 /// An interactive cross-platform application.
 ///
@@ -198,24 +198,24 @@ pub trait Application: Sized {
             default_font: settings.default_font,
             default_text_size: settings.default_text_size,
             antialiasing: if settings.antialiasing {
-                Some(crate::renderer::Antialiasing::MSAAx4)
+                Some(crate::graphics::Antialiasing::MSAAx4)
             } else {
                 None
             },
             ..crate::renderer::Settings::default()
         };
 
-        Ok(crate::runtime::application::run::<
+        Ok(crate::shell::application::run::<
             Instance<Self>,
             Self::Executor,
-            crate::renderer::window::Compositor<Self::Theme>,
+            crate::renderer::Compositor<Self::Theme>,
         >(settings.into(), renderer_settings)?)
     }
 }
 
 struct Instance<A: Application>(A);
 
-impl<A> iced_winit::Program for Instance<A>
+impl<A> crate::native::Program for Instance<A>
 where
     A: Application,
 {
@@ -231,7 +231,7 @@ where
     }
 }
 
-impl<A> crate::runtime::Application for Instance<A>
+impl<A> crate::shell::Application for Instance<A>
 where
     A: Application,
 {
diff --git a/src/clipboard.rs b/src/clipboard.rs
deleted file mode 100644
index dde17051..00000000
--- a/src/clipboard.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Access the clipboard.
-#[cfg(not(target_arch = "wasm32"))]
-pub use crate::runtime::clipboard::{read, write};
diff --git a/src/element.rs b/src/element.rs
deleted file mode 100644
index 2eb1bb4d..00000000
--- a/src/element.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-/// A generic widget.
-///
-/// This is an alias of an `iced_native` element with a default `Renderer`.
-pub type Element<'a, Message, Renderer = crate::Renderer> =
-    crate::runtime::Element<'a, Message, Renderer>;
diff --git a/src/error.rs b/src/error.rs
index 5326718f..111bedf2 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,4 +1,6 @@
-use iced_futures::futures;
+use crate::futures;
+use crate::graphics;
+use crate::shell;
 
 /// An error that occurred while running an application.
 #[derive(Debug, thiserror::Error)]
@@ -13,19 +15,19 @@ pub enum Error {
 
     /// The application graphics context could not be created.
     #[error("the application graphics context could not be created")]
-    GraphicsCreationFailed(iced_renderer::Error),
+    GraphicsCreationFailed(graphics::Error),
 }
 
-impl From<iced_winit::Error> for Error {
-    fn from(error: iced_winit::Error) -> Error {
+impl From<shell::Error> for Error {
+    fn from(error: shell::Error) -> Error {
         match error {
-            iced_winit::Error::ExecutorCreationFailed(error) => {
+            shell::Error::ExecutorCreationFailed(error) => {
                 Error::ExecutorCreationFailed(error)
             }
-            iced_winit::Error::WindowCreationFailed(error) => {
+            shell::Error::WindowCreationFailed(error) => {
                 Error::WindowCreationFailed(Box::new(error))
             }
-            iced_winit::Error::GraphicsCreationFailed(error) => {
+            shell::Error::GraphicsCreationFailed(error) => {
                 Error::GraphicsCreationFailed(error)
             }
         }
diff --git a/src/executor.rs b/src/executor.rs
deleted file mode 100644
index 36ae274e..00000000
--- a/src/executor.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Choose your preferred executor to power your application.
-pub use crate::runtime::Executor;
-
-/// A default cross-platform executor.
-///
-/// - On native platforms, it will use:
-///   - `iced_futures::backend::native::tokio` when the `tokio` feature is enabled.
-///   - `iced_futures::backend::native::async-std` when the `async-std` feature is
-///     enabled.
-///   - `iced_futures::backend::native::smol` when the `smol` feature is enabled.
-///   - `iced_futures::backend::native::thread_pool` otherwise.
-///
-/// - On Wasm, it will use `iced_futures::backend::wasm::wasm_bindgen`.
-pub type Default = iced_futures::backend::default::Executor;
diff --git a/src/keyboard.rs b/src/keyboard.rs
deleted file mode 100644
index 2134a66b..00000000
--- a/src/keyboard.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-//! Listen and react to keyboard events.
-pub use crate::runtime::keyboard::{Event, KeyCode, Modifiers};
diff --git a/src/lib.rs b/src/lib.rs
index bb162f2d..b71b7781 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -164,51 +164,133 @@
 #![forbid(rust_2018_idioms, unsafe_code)]
 #![allow(clippy::inherent_to_string, clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+use iced_widget::graphics;
+use iced_widget::renderer;
+use iced_widget::style;
+use iced_winit as shell;
+use iced_winit::core;
+use iced_winit::native;
+
+pub use iced_futures::futures;
 
-mod element;
 mod error;
-mod result;
 mod sandbox;
 
 pub mod application;
-pub mod clipboard;
-pub mod executor;
-pub mod keyboard;
-pub mod mouse;
-pub mod overlay;
 pub mod settings;
 pub mod time;
-pub mod touch;
-pub mod widget;
 pub mod window;
 
-use iced_renderer as renderer;
-use iced_winit as runtime;
+#[cfg(feature = "advanced")]
+pub mod advanced;
+
+pub use style::theme;
+
+pub use crate::core::alignment;
+pub use crate::core::event;
+pub use crate::core::{
+    color, Alignment, Background, Color, ContentFit, Length, Padding, Point,
+    Rectangle, Size, Vector,
+};
+pub use crate::native::Command;
+pub use native::subscription;
+
+pub mod clipboard {
+    //! Access the clipboard.
+    pub use crate::shell::clipboard::{read, write};
+}
+
+pub mod executor {
+    //! Choose your preferred executor to power your application.
+    pub use iced_futures::Executor;
+
+    /// A default cross-platform executor.
+    ///
+    /// - On native platforms, it will use:
+    ///   - `iced_futures::backend::native::tokio` when the `tokio` feature is enabled.
+    ///   - `iced_futures::backend::native::async-std` when the `async-std` feature is
+    ///     enabled.
+    ///   - `iced_futures::backend::native::smol` when the `smol` feature is enabled.
+    ///   - `iced_futures::backend::native::thread_pool` otherwise.
+    ///
+    /// - On Wasm, it will use `iced_futures::backend::wasm::wasm_bindgen`.
+    pub type Default = iced_futures::backend::default::Executor;
+}
+
+pub mod font {
+    //! Load and use fonts.
+    pub use crate::core::font::*;
+    pub use crate::native::font::*;
+}
+
+pub mod keyboard {
+    //! Listen and react to keyboard events.
+    pub use crate::core::keyboard::{Event, KeyCode, Modifiers};
+}
+
+pub mod mouse {
+    //! Listen and react to mouse events.
+    pub use crate::core::mouse::{Button, Event, Interaction, ScrollDelta};
+}
 
-pub use iced_native::theme;
-pub use runtime::event;
-pub use runtime::font;
-pub use runtime::subscription;
+#[cfg(feature = "system")]
+pub mod system {
+    //! Retrieve system information.
+    pub use crate::native::system::Information;
+    pub use crate::shell::system::*;
+}
+
+pub mod overlay {
+    //! Display interactive elements on top of other widgets.
+
+    /// A generic [`Overlay`].
+    ///
+    /// This is an alias of an `iced_native` element with a default `Renderer`.
+    ///
+    /// [`Overlay`]: iced_native::Overlay
+    pub type Element<'a, Message, Renderer = crate::Renderer> =
+        crate::core::overlay::Element<'a, Message, Renderer>;
+
+    pub use iced_widget::overlay::*;
+}
+
+pub mod touch {
+    //! Listen and react to touch events.
+    pub use crate::core::touch::{Event, Finger};
+}
+
+pub mod widget {
+    //! Use the built-in widgets or create your own.
+    pub use iced_widget::*;
+
+    // We hide the re-exported modules by `iced_widget`
+    mod core {}
+    mod graphics {}
+    mod native {}
+    mod renderer {}
+    mod style {}
+}
 
 pub use application::Application;
-pub use element::Element;
 pub use error::Error;
 pub use event::Event;
 pub use executor::Executor;
 pub use font::Font;
-pub use renderer::Renderer;
-pub use result::Result;
 pub use sandbox::Sandbox;
 pub use settings::Settings;
 pub use subscription::Subscription;
 pub use theme::Theme;
 
-pub use runtime::alignment;
-pub use runtime::futures;
-pub use runtime::{
-    color, Alignment, Background, Color, Command, ContentFit, Length, Padding,
-    Point, Rectangle, Size, Vector,
-};
+/// The default renderer.
+pub type Renderer<Theme = style::Theme> = renderer::Renderer<Theme>;
 
-#[cfg(feature = "system")]
-pub use runtime::system;
+/// A generic widget.
+///
+/// This is an alias of an `iced_native` element with a default `Renderer`.
+pub type Element<'a, Message, Renderer = crate::Renderer> =
+    crate::core::Element<'a, Message, Renderer>;
+
+/// The result of running an [`Application`].
+///
+/// [`Application`]: crate::Application
+pub type Result = std::result::Result<(), Error>;
diff --git a/src/mouse.rs b/src/mouse.rs
deleted file mode 100644
index d61ed09a..00000000
--- a/src/mouse.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-//! Listen and react to mouse events.
-pub use crate::runtime::mouse::{Button, Event, Interaction, ScrollDelta};
diff --git a/src/overlay.rs b/src/overlay.rs
deleted file mode 100644
index c0f4c492..00000000
--- a/src/overlay.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! Display interactive elements on top of other widgets.
-
-/// A generic [`Overlay`].
-///
-/// This is an alias of an `iced_native` element with a default `Renderer`.
-///
-/// [`Overlay`]: iced_native::Overlay
-pub type Element<'a, Message, Renderer = crate::Renderer> =
-    iced_native::overlay::Element<'a, Message, Renderer>;
-
-pub mod menu {
-    //! Build and show dropdown menus.
-    pub use iced_native::overlay::menu::{Appearance, State, StyleSheet};
-
-    /// A widget that produces a message when clicked.
-    pub type Menu<'a, Message, Renderer = crate::Renderer> =
-        iced_native::overlay::Menu<'a, Message, Renderer>;
-}
diff --git a/src/result.rs b/src/result.rs
deleted file mode 100644
index ef565bd6..00000000
--- a/src/result.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use crate::Error;
-
-/// The result of running an [`Application`].
-///
-/// [`Application`]: crate::Application
-pub type Result = std::result::Result<(), Error>;
diff --git a/src/touch.rs b/src/touch.rs
index 0b77c386..f2bdfca8 100644
--- a/src/touch.rs
+++ b/src/touch.rs
@@ -1,2 +1,2 @@
 //! Listen and react to touch events.
-pub use crate::runtime::touch::{Event, Finger};
+pub use crate::core::touch::{Event, Finger};
diff --git a/src/widget.rs b/src/widget.rs
deleted file mode 100644
index 19434e84..00000000
--- a/src/widget.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-//! Display information and interactive controls in your application.
-pub use iced_native::widget::helpers::*;
-
-pub use iced_native::{column, row};
-
-/// A container that distributes its contents vertically.
-pub type Column<'a, Message, Renderer = crate::Renderer> =
-    iced_native::widget::Column<'a, Message, Renderer>;
-
-/// A container that distributes its contents horizontally.
-pub type Row<'a, Message, Renderer = crate::Renderer> =
-    iced_native::widget::Row<'a, Message, Renderer>;
-
-pub mod text {
-    //! Write some text for your users to read.
-    pub use iced_native::widget::text::{Appearance, StyleSheet};
-
-    /// A paragraph of text.
-    pub type Text<'a, Renderer = crate::Renderer> =
-        iced_native::widget::Text<'a, Renderer>;
-}
-
-pub mod button {
-    //! Allow your users to perform actions by pressing a button.
-    pub use iced_native::widget::button::{Appearance, StyleSheet};
-
-    /// A widget that produces a message when clicked.
-    pub type Button<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Button<'a, Message, Renderer>;
-}
-
-pub mod checkbox {
-    //! Show toggle controls using checkboxes.
-    pub use iced_native::widget::checkbox::{Appearance, Icon, StyleSheet};
-
-    /// A box that can be checked.
-    pub type Checkbox<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Checkbox<'a, Message, Renderer>;
-}
-
-pub mod container {
-    //! Decorate content and apply alignment.
-    pub use iced_native::widget::container::{Appearance, StyleSheet};
-
-    /// An element decorating some content.
-    pub type Container<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Container<'a, Message, Renderer>;
-}
-
-pub mod pane_grid {
-    //! Let your users split regions of your application and organize layout dynamically.
-    //!
-    //! [![Pane grid - Iced](https://thumbs.gfycat.com/MixedFlatJellyfish-small.gif)](https://gfycat.com/mixedflatjellyfish)
-    //!
-    //! # Example
-    //! The [`pane_grid` example] showcases how to use a [`PaneGrid`] with resizing,
-    //! drag and drop, and hotkey support.
-    //!
-    //! [`pane_grid` example]: https://github.com/iced-rs/iced/tree/0.8/examples/pane_grid
-    pub use iced_native::widget::pane_grid::{
-        Axis, Configuration, Direction, DragEvent, Line, Node, Pane,
-        ResizeEvent, Split, State, StyleSheet,
-    };
-
-    /// A collection of panes distributed using either vertical or horizontal splits
-    /// to completely fill the space available.
-    ///
-    /// [![Pane grid - Iced](https://thumbs.gfycat.com/MixedFlatJellyfish-small.gif)](https://gfycat.com/mixedflatjellyfish)
-    pub type PaneGrid<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::PaneGrid<'a, Message, Renderer>;
-
-    /// The content of a [`Pane`].
-    pub type Content<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::pane_grid::Content<'a, Message, Renderer>;
-
-    /// The title bar of a [`Pane`].
-    pub type TitleBar<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::pane_grid::TitleBar<'a, Message, Renderer>;
-}
-
-pub mod pick_list {
-    //! Display a dropdown list of selectable values.
-    pub use iced_native::widget::pick_list::{
-        Appearance, Handle, Icon, StyleSheet,
-    };
-
-    /// A widget allowing the selection of a single value from a list of options.
-    pub type PickList<'a, T, Message, Renderer = crate::Renderer> =
-        iced_native::widget::PickList<'a, T, Message, Renderer>;
-}
-
-pub mod radio {
-    //! Create choices using radio buttons.
-    pub use iced_native::widget::radio::{Appearance, StyleSheet};
-
-    /// A circular button representing a choice.
-    pub type Radio<Message, Renderer = crate::Renderer> =
-        iced_native::widget::Radio<Message, Renderer>;
-}
-
-pub mod scrollable {
-    //! Navigate an endless amount of content with a scrollbar.
-    pub use iced_native::widget::scrollable::{
-        snap_to, style::Scrollbar, style::Scroller, Id, Properties,
-        RelativeOffset, StyleSheet,
-    };
-
-    /// A widget that can vertically display an infinite amount of content
-    /// with a scrollbar.
-    pub type Scrollable<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Scrollable<'a, Message, Renderer>;
-}
-
-pub mod toggler {
-    //! Show toggle controls using togglers.
-    pub use iced_native::widget::toggler::{Appearance, StyleSheet};
-
-    /// A toggler widget.
-    pub type Toggler<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Toggler<'a, Message, Renderer>;
-}
-
-pub mod text_input {
-    //! Display fields that can be filled with text.
-    pub use iced_native::widget::text_input::{
-        focus, move_cursor_to, move_cursor_to_end, move_cursor_to_front,
-        select_all, Appearance, Id, StyleSheet,
-    };
-
-    /// A field that can be filled with text.
-    pub type TextInput<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::TextInput<'a, Message, Renderer>;
-}
-
-pub mod tooltip {
-    //! Display a widget over another.
-    pub use iced_native::widget::tooltip::Position;
-
-    /// A widget allowing the selection of a single value from a list of options.
-    pub type Tooltip<'a, Message, Renderer = crate::Renderer> =
-        iced_native::widget::Tooltip<'a, Message, Renderer>;
-}
-
-pub use iced_native::widget::progress_bar;
-pub use iced_native::widget::rule;
-pub use iced_native::widget::slider;
-pub use iced_native::widget::vertical_slider;
-pub use iced_native::widget::Space;
-
-pub use button::Button;
-pub use checkbox::Checkbox;
-pub use container::Container;
-pub use pane_grid::PaneGrid;
-pub use pick_list::PickList;
-pub use progress_bar::ProgressBar;
-pub use radio::Radio;
-pub use rule::Rule;
-pub use scrollable::Scrollable;
-pub use slider::Slider;
-pub use text::Text;
-pub use text_input::TextInput;
-pub use toggler::Toggler;
-pub use tooltip::Tooltip;
-pub use vertical_slider::VerticalSlider;
-
-#[cfg(feature = "canvas")]
-#[cfg_attr(docsrs, doc(cfg(feature = "canvas")))]
-pub mod canvas;
-
-#[cfg(feature = "canvas")]
-#[cfg_attr(docsrs, doc(cfg(feature = "canvas")))]
-/// Creates a new [`Canvas`].
-pub fn canvas<P, Message, Renderer>(program: P) -> Canvas<P, Message, Renderer>
-where
-    Renderer: iced_renderer::geometry::Renderer,
-    P: canvas::Program<Message, Renderer>,
-{
-    Canvas::new(program)
-}
-
-#[cfg(feature = "image")]
-#[cfg_attr(docsrs, doc(cfg(feature = "image")))]
-pub mod image {
-    //! Display images in your user interface.
-    pub use iced_native::image::Handle;
-
-    /// A frame that displays an image.
-    pub type Image = iced_native::widget::Image<Handle>;
-
-    pub use iced_native::widget::image::viewer;
-    pub use viewer::Viewer;
-}
-
-#[cfg(feature = "qr_code")]
-#[cfg_attr(docsrs, doc(cfg(feature = "qr_code")))]
-pub mod qr_code;
-
-#[cfg(feature = "svg")]
-#[cfg_attr(docsrs, doc(cfg(feature = "svg")))]
-pub mod svg {
-    //! Display vector graphics in your application.
-    pub use iced_native::svg::Handle;
-    pub use iced_native::widget::svg::{Appearance, StyleSheet, Svg};
-}
-
-#[cfg(feature = "canvas")]
-#[cfg_attr(docsrs, doc(cfg(feature = "canvas")))]
-pub use canvas::Canvas;
-
-#[cfg(feature = "image")]
-#[cfg_attr(docsrs, doc(cfg(feature = "image")))]
-pub use image::Image;
-
-#[cfg(feature = "qr_code")]
-#[cfg_attr(docsrs, doc(cfg(feature = "qr_code")))]
-pub use qr_code::QRCode;
-
-#[cfg(feature = "svg")]
-#[cfg_attr(docsrs, doc(cfg(feature = "svg")))]
-pub use svg::Svg;
-
-use crate::Command;
-use iced_native::widget::operation;
-
-/// Focuses the previous focusable widget.
-pub fn focus_previous<Message>() -> Command<Message>
-where
-    Message: 'static,
-{
-    Command::widget(operation::focusable::focus_previous())
-}
-
-/// Focuses the next focusable widget.
-pub fn focus_next<Message>() -> Command<Message>
-where
-    Message: 'static,
-{
-    Command::widget(operation::focusable::focus_next())
-}
diff --git a/src/window.rs b/src/window.rs
index 2018053f..26239065 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -8,5 +8,6 @@ pub use icon::Icon;
 pub use position::Position;
 pub use settings::Settings;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub use crate::runtime::window::*;
+pub use crate::core::window::*;
+pub use crate::native::window::*;
+pub use crate::shell::window::*;
diff --git a/src/widget/canvas.rs b/widget/src/canvas.rs
index bc5995c6..171c4534 100644
--- a/src/widget/canvas.rs
+++ b/widget/src/canvas.rs
@@ -8,15 +8,17 @@ pub use cursor::Cursor;
 pub use event::Event;
 pub use program::Program;
 
-pub use iced_renderer::geometry::*;
-
-use crate::{Length, Point, Rectangle, Size, Vector};
-
-use iced_native::layout::{self, Layout};
-use iced_native::mouse;
-use iced_native::renderer;
-use iced_native::widget::tree::{self, Tree};
-use iced_native::{Clipboard, Element, Shell, Widget};
+pub use crate::graphics::geometry::*;
+pub use crate::renderer::geometry::*;
+
+use crate::core;
+use crate::core::layout::{self, Layout};
+use crate::core::mouse;
+use crate::core::renderer;
+use crate::core::widget::tree::{self, Tree};
+use crate::core::{Clipboard, Element, Shell, Widget};
+use crate::core::{Length, Point, Rectangle, Size, Vector};
+use crate::graphics::geometry;
 
 use std::marker::PhantomData;
 
@@ -26,9 +28,11 @@ use std::marker::PhantomData;
 /// If you want to get a quick overview, here's how we can draw a simple circle:
 ///
 /// ```no_run
-/// use iced::widget::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
-/// use iced::{Color, Rectangle, Theme, Renderer};
-///
+/// # use iced_widget::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
+/// # use iced_widget::core::{Color, Rectangle};
+/// # use iced_widget::style::Theme;
+/// #
+/// # pub type Renderer = iced_widget::renderer::Renderer<Theme>;
 /// // First, we define the data we need for drawing
 /// #[derive(Debug)]
 /// struct Circle {
@@ -60,7 +64,7 @@ use std::marker::PhantomData;
 #[derive(Debug)]
 pub struct Canvas<P, Message, Renderer = crate::Renderer>
 where
-    Renderer: iced_renderer::geometry::Renderer,
+    Renderer: geometry::Renderer,
     P: Program<Message, Renderer>,
 {
     width: Length,
@@ -72,7 +76,7 @@ where
 
 impl<P, Message, Renderer> Canvas<P, Message, Renderer>
 where
-    Renderer: iced_renderer::geometry::Renderer,
+    Renderer: geometry::Renderer,
     P: Program<Message, Renderer>,
 {
     const DEFAULT_SIZE: f32 = 100.0;
@@ -104,7 +108,7 @@ where
 impl<P, Message, Renderer> Widget<Message, Renderer>
     for Canvas<P, Message, Renderer>
 where
-    Renderer: iced_renderer::geometry::Renderer,
+    Renderer: geometry::Renderer,
     P: Program<Message, Renderer>,
 {
     fn tag(&self) -> tree::Tag {
@@ -138,7 +142,7 @@ where
     fn on_event(
         &mut self,
         tree: &mut Tree,
-        event: iced_native::Event,
+        event: core::Event,
         layout: Layout<'_>,
         cursor_position: Point,
         _renderer: &Renderer,
@@ -148,13 +152,9 @@ where
         let bounds = layout.bounds();
 
         let canvas_event = match event {
-            iced_native::Event::Mouse(mouse_event) => {
-                Some(Event::Mouse(mouse_event))
-            }
-            iced_native::Event::Touch(touch_event) => {
-                Some(Event::Touch(touch_event))
-            }
-            iced_native::Event::Keyboard(keyboard_event) => {
+            core::Event::Mouse(mouse_event) => Some(Event::Mouse(mouse_event)),
+            core::Event::Touch(touch_event) => Some(Event::Touch(touch_event)),
+            core::Event::Keyboard(keyboard_event) => {
                 Some(Event::Keyboard(keyboard_event))
             }
             _ => None,
@@ -227,7 +227,7 @@ impl<'a, P, Message, Renderer> From<Canvas<P, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
     Message: 'a,
-    Renderer: 'a + iced_renderer::geometry::Renderer,
+    Renderer: 'a + geometry::Renderer,
     P: Program<Message, Renderer> + 'a,
 {
     fn from(
diff --git a/src/widget/canvas/cursor.rs b/widget/src/canvas/cursor.rs
index ef6a7771..5a65e9a7 100644
--- a/src/widget/canvas/cursor.rs
+++ b/widget/src/canvas/cursor.rs
@@ -1,4 +1,4 @@
-use crate::{Point, Rectangle};
+use crate::core::{Point, Rectangle};
 
 /// The mouse cursor state.
 #[derive(Debug, Clone, Copy, PartialEq)]
diff --git a/src/widget/canvas/event.rs b/widget/src/canvas/event.rs
index 7c733a4d..4508c184 100644
--- a/src/widget/canvas/event.rs
+++ b/widget/src/canvas/event.rs
@@ -1,9 +1,9 @@
 //! Handle events of a canvas.
-use iced_native::keyboard;
-use iced_native::mouse;
-use iced_native::touch;
+use crate::core::keyboard;
+use crate::core::mouse;
+use crate::core::touch;
 
-pub use iced_native::event::Status;
+pub use crate::core::event::Status;
 
 /// A [`Canvas`] event.
 ///
diff --git a/src/widget/canvas/program.rs b/widget/src/canvas/program.rs
index fd15663a..efb33c56 100644
--- a/src/widget/canvas/program.rs
+++ b/widget/src/canvas/program.rs
@@ -1,7 +1,8 @@
-use crate::widget::canvas::event::{self, Event};
-use crate::widget::canvas::mouse;
-use crate::widget::canvas::Cursor;
-use crate::Rectangle;
+use crate::canvas::event::{self, Event};
+use crate::canvas::mouse;
+use crate::canvas::Cursor;
+use crate::core::Rectangle;
+use crate::graphics::geometry;
 
 /// The state and logic of a [`Canvas`].
 ///
@@ -11,7 +12,7 @@ use crate::Rectangle;
 /// [`Canvas`]: crate::widget::Canvas
 pub trait Program<Message, Renderer = crate::Renderer>
 where
-    Renderer: iced_renderer::geometry::Renderer,
+    Renderer: geometry::Renderer,
 {
     /// The internal state mutated by the [`Program`].
     type State: Default + 'static;
@@ -71,7 +72,7 @@ where
 
 impl<Message, Renderer, T> Program<Message, Renderer> for &T
 where
-    Renderer: iced_renderer::geometry::Renderer,
+    Renderer: geometry::Renderer,
     T: Program<Message, Renderer>,
 {
     type State = T::State;
diff --git a/src/widget/qr_code.rs b/widget/src/qr_code.rs
index 66442d5d..7709125f 100644
--- a/src/widget/qr_code.rs
+++ b/widget/src/qr_code.rs
@@ -1,13 +1,12 @@
 //! Encode and display information in a QR code.
-use crate::widget::canvas;
-use crate::Renderer;
-
-use iced_native::layout;
-use iced_native::renderer;
-use iced_native::widget::Tree;
-use iced_native::{
+use crate::canvas;
+use crate::core::layout;
+use crate::core::renderer::{self, Renderer as _};
+use crate::core::widget::Tree;
+use crate::core::{
     Color, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
 };
+use crate::Renderer;
 use thiserror::Error;
 
 const DEFAULT_CELL_SIZE: u16 = 4;
@@ -78,8 +77,6 @@ impl<'a, Message, Theme> Widget<Message, Renderer<Theme>> for QRCode<'a> {
         _cursor_position: Point,
         _viewport: &Rectangle,
     ) {
-        use iced_native::Renderer as _;
-
         let bounds = layout.bounds();
         let side_length = self.state.width + 2 * QUIET_ZONE;