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

1 files changed, 83 insertions, 85 deletions

diff --git a/native/src/widget/scrollable.rs b/widget/src/scrollable.rs
index c1df8c39..49c780de 100644
--- a/native/src/widget/scrollable.rs
+++ b/widget/src/scrollable.rs
@@ -1,35 +1,29 @@
 //! Navigate an endless amount of content with a scrollbar.
-use crate::event::{self, Event};
-use crate::keyboard;
-use crate::layout;
-use crate::mouse;
-use crate::overlay;
-use crate::renderer;
-use crate::touch;
-use crate::widget;
-use crate::widget::operation::{self, Operation};
-use crate::widget::tree::{self, Tree};
-use crate::{
-    Background, Clipboard, Color, Command, Element, Layout, Length, Pixels,
-    Point, Rectangle, Shell, Size, Vector, Widget,
+use crate::core::event::{self, Event};
+use crate::core::keyboard;
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::overlay;
+use crate::core::renderer;
+use crate::core::touch;
+use crate::core::widget;
+use crate::core::widget::operation::{self, Operation};
+use crate::core::widget::tree::{self, Tree};
+use crate::core::{
+    Background, Clipboard, Color, Element, Layout, Length, Pixels, Point,
+    Rectangle, Shell, Size, Vector, Widget,
 };
+use crate::native::Command;
 
-pub use iced_style::scrollable::StyleSheet;
+pub use crate::style::scrollable::{Scrollbar, Scroller, StyleSheet};
 pub use operation::scrollable::RelativeOffset;
 
-pub mod style {
-    //! The styles of a [`Scrollable`].
-    //!
-    //! [`Scrollable`]: crate::widget::Scrollable
-    pub use iced_style::scrollable::{Scrollbar, Scroller};
-}
-
 /// A widget that can vertically display an infinite amount of content with a
 /// scrollbar.
 #[allow(missing_debug_implementations)]
-pub struct Scrollable<'a, Message, Renderer>
+pub struct Scrollable<'a, Message, Renderer = crate::Renderer>
 where
-    Renderer: crate::Renderer,
+    Renderer: crate::core::Renderer,
     Renderer::Theme: StyleSheet,
 {
     id: Option<Id>,
@@ -43,7 +37,7 @@ where
 
 impl<'a, Message, Renderer> Scrollable<'a, Message, Renderer>
 where
-    Renderer: crate::Renderer,
+    Renderer: crate::core::Renderer,
     Renderer::Theme: StyleSheet,
 {
     /// Creates a new [`Scrollable`].
@@ -153,7 +147,7 @@ impl Properties {
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Scrollable<'a, Message, Renderer>
 where
-    Renderer: crate::Renderer,
+    Renderer: crate::core::Renderer,
     Renderer::Theme: StyleSheet,
 {
     fn tag(&self) -> tree::Tag {
@@ -345,7 +339,7 @@ impl<'a, Message, Renderer> From<Scrollable<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
     Message: 'a,
-    Renderer: 'a + crate::Renderer,
+    Renderer: 'a + crate::core::Renderer,
     Renderer::Theme: StyleSheet,
 {
     fn from(
@@ -763,7 +757,7 @@ pub fn draw<Renderer>(
     style: &<Renderer::Theme as StyleSheet>::Style,
     draw_content: impl FnOnce(&mut Renderer, Layout<'_>, Point, &Rectangle),
 ) where
-    Renderer: crate::Renderer,
+    Renderer: crate::core::Renderer,
     Renderer::Theme: StyleSheet,
 {
     let bounds = layout.bounds();
@@ -809,8 +803,8 @@ pub fn draw<Renderer>(
 
         let draw_scrollbar =
             |renderer: &mut Renderer,
-             style: style::Scrollbar,
-             scrollbar: &Scrollbar| {
+             style: Scrollbar,
+             scrollbar: &internals::Scrollbar| {
                 //track
                 if style.background.is_some()
                     || (style.border_color != Color::TRANSPARENT
@@ -1068,8 +1062,8 @@ impl State {
 #[derive(Debug)]
 /// State of both [`Scrollbar`]s.
 struct Scrollbars {
-    y: Option<Scrollbar>,
-    x: Option<Scrollbar>,
+    y: Option<internals::Scrollbar>,
+    x: Option<internals::Scrollbar>,
 }
 
 impl Scrollbars {
@@ -1139,10 +1133,10 @@ impl Scrollbars {
                 height: scroller_height,
             };
 
-            Some(Scrollbar {
+            Some(internals::Scrollbar {
                 total_bounds: total_scrollbar_bounds,
                 bounds: scrollbar_bounds,
-                scroller: Scroller {
+                scroller: internals::Scroller {
                     bounds: scroller_bounds,
                 },
             })
@@ -1199,10 +1193,10 @@ impl Scrollbars {
                 height: scroller_width,
             };
 
-            Some(Scrollbar {
+            Some(internals::Scrollbar {
                 total_bounds: total_scrollbar_bounds,
                 bounds: scrollbar_bounds,
-                scroller: Scroller {
+                scroller: internals::Scroller {
                     bounds: scroller_bounds,
                 },
             })
@@ -1264,64 +1258,68 @@ impl Scrollbars {
     }
 }
 
-/// The scrollbar of a [`Scrollable`].
-#[derive(Debug, Copy, Clone)]
-struct Scrollbar {
-    /// The total bounds of the [`Scrollbar`], including the scrollbar, the scroller,
-    /// and the scrollbar margin.
-    total_bounds: Rectangle,
+pub(super) mod internals {
+    use crate::core::{Point, Rectangle};
 
-    /// The bounds of just the [`Scrollbar`].
-    bounds: Rectangle,
+    /// The scrollbar of a [`Scrollable`].
+    #[derive(Debug, Copy, Clone)]
+    pub struct Scrollbar {
+        /// The total bounds of the [`Scrollbar`], including the scrollbar, the scroller,
+        /// and the scrollbar margin.
+        pub total_bounds: Rectangle,
 
-    /// The state of this scrollbar's [`Scroller`].
-    scroller: Scroller,
-}
+        /// The bounds of just the [`Scrollbar`].
+        pub bounds: Rectangle,
 
-impl Scrollbar {
-    /// Returns whether the mouse is over the scrollbar or not.
-    fn is_mouse_over(&self, cursor_position: Point) -> bool {
-        self.total_bounds.contains(cursor_position)
+        /// The state of this scrollbar's [`Scroller`].
+        pub scroller: Scroller,
     }
 
-    /// Returns the y-axis scrolled percentage from the cursor position.
-    fn scroll_percentage_y(
-        &self,
-        grabbed_at: f32,
-        cursor_position: Point,
-    ) -> f32 {
-        if cursor_position.x < 0.0 && cursor_position.y < 0.0 {
-            // cursor position is unavailable! Set to either end or beginning of scrollbar depending
-            // on where the thumb currently is in the track
-            (self.scroller.bounds.y / self.total_bounds.height).round()
-        } else {
-            (cursor_position.y
-                - self.bounds.y
-                - self.scroller.bounds.height * grabbed_at)
-                / (self.bounds.height - self.scroller.bounds.height)
+    impl Scrollbar {
+        /// Returns whether the mouse is over the scrollbar or not.
+        pub fn is_mouse_over(&self, cursor_position: Point) -> bool {
+            self.total_bounds.contains(cursor_position)
         }
-    }
 
-    /// Returns the x-axis scrolled percentage from the cursor position.
-    fn scroll_percentage_x(
-        &self,
-        grabbed_at: f32,
-        cursor_position: Point,
-    ) -> f32 {
-        if cursor_position.x < 0.0 && cursor_position.y < 0.0 {
-            (self.scroller.bounds.x / self.total_bounds.width).round()
-        } else {
-            (cursor_position.x
-                - self.bounds.x
-                - self.scroller.bounds.width * grabbed_at)
-                / (self.bounds.width - self.scroller.bounds.width)
+        /// Returns the y-axis scrolled percentage from the cursor position.
+        pub fn scroll_percentage_y(
+            &self,
+            grabbed_at: f32,
+            cursor_position: Point,
+        ) -> f32 {
+            if cursor_position.x < 0.0 && cursor_position.y < 0.0 {
+                // cursor position is unavailable! Set to either end or beginning of scrollbar depending
+                // on where the thumb currently is in the track
+                (self.scroller.bounds.y / self.total_bounds.height).round()
+            } else {
+                (cursor_position.y
+                    - self.bounds.y
+                    - self.scroller.bounds.height * grabbed_at)
+                    / (self.bounds.height - self.scroller.bounds.height)
+            }
+        }
+
+        /// Returns the x-axis scrolled percentage from the cursor position.
+        pub fn scroll_percentage_x(
+            &self,
+            grabbed_at: f32,
+            cursor_position: Point,
+        ) -> f32 {
+            if cursor_position.x < 0.0 && cursor_position.y < 0.0 {
+                (self.scroller.bounds.x / self.total_bounds.width).round()
+            } else {
+                (cursor_position.x
+                    - self.bounds.x
+                    - self.scroller.bounds.width * grabbed_at)
+                    / (self.bounds.width - self.scroller.bounds.width)
+            }
         }
     }
-}
 
-/// The handle of a [`Scrollbar`].
-#[derive(Debug, Clone, Copy)]
-struct Scroller {
-    /// The bounds of the [`Scroller`].
-    bounds: Rectangle,
+    /// The handle of a [`Scrollbar`].
+    #[derive(Debug, Clone, Copy)]
+    pub struct Scroller {
+        /// The bounds of the [`Scroller`].
+        pub bounds: Rectangle,
+    }
 }