4 files changed, 17 insertions, 66 deletions

diff --git a/native/src/layout/debugger.rs b/native/src/layout/debugger.rs
index e4b21609..0759613f 100644
--- a/native/src/layout/debugger.rs
+++ b/native/src/layout/debugger.rs
@@ -1,8 +1,6 @@
-use crate::{Color, Layout, Point, Renderer, Widget};
+use crate::{Color, Layout, Point, Rectangle, Renderer, Widget};
 
 /// A renderer able to graphically explain a [`Layout`].
-///
-/// [`Layout`]: struct.Layout.html
 pub trait Debugger: Renderer {
     /// Explains the [`Layout`] of an [`Element`] for debugging purposes.
     ///
@@ -12,15 +10,15 @@ pub trait Debugger: Renderer {
     /// A common approach consists in recursively rendering the bounds of the
     /// [`Layout`] and its children.
     ///
-    /// [`Layout`]: struct.Layout.html
-    /// [`Element`]: ../struct.Element.html
-    /// [`Element::explain`]: ../struct.Element.html#method.explain
+    /// [`Element`]: crate::Element
+    /// [`Element::explain`]: crate::Element::explain
     fn explain<Message>(
         &mut self,
         defaults: &Self::Defaults,
         widget: &dyn Widget<Message, Self>,
         layout: Layout<'_>,
         cursor_position: Point,
+        viewport: &Rectangle,
         color: Color,
     ) -> Self::Output;
 }
diff --git a/native/src/layout/flex.rs b/native/src/layout/flex.rs
index 9da75a21..3d3ff82c 100644
--- a/native/src/layout/flex.rs
+++ b/native/src/layout/flex.rs
@@ -16,9 +16,10 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 use crate::{
     layout::{Limits, Node},
-    Align, Element, Point, Size,
+    Align, Element, Padding, Point, Size,
 };
 
 /// The main axis of a flex layout.
@@ -58,13 +59,11 @@ impl Axis {
 /// padding and alignment to the items as needed.
 ///
 /// It returns a new layout [`Node`].
-///
-/// [`Node`]: ../struct.Node.html
 pub fn resolve<Message, Renderer>(
     axis: Axis,
     renderer: &Renderer,
     limits: &Limits,
-    padding: f32,
+    padding: Padding,
     spacing: f32,
     align_items: Align,
     items: &[Element<'_, Message, Renderer>],
@@ -143,14 +142,15 @@ where
         }
     }
 
-    let mut main = padding;
+    let pad = axis.pack(padding.left as f32, padding.top as f32);
+    let mut main = pad.0;
 
     for (i, node) in nodes.iter_mut().enumerate() {
         if i > 0 {
             main += spacing;
         }
 
-        let (x, y) = axis.pack(main, padding);
+        let (x, y) = axis.pack(main, pad.1);
 
         node.move_to(Point::new(x, y));
 
@@ -168,7 +168,7 @@ where
         main += axis.main(size);
     }
 
-    let (width, height) = axis.pack(main - padding, cross);
+    let (width, height) = axis.pack(main - pad.0, cross);
     let size = limits.resolve(Size::new(width, height));
 
     Node::with_children(size.pad(padding), nodes)
diff --git a/native/src/layout/limits.rs b/native/src/layout/limits.rs
index 664c881a..6d5f6563 100644
--- a/native/src/layout/limits.rs
+++ b/native/src/layout/limits.rs
@@ -1,4 +1,4 @@
-use crate::{Length, Size};
+use crate::{Length, Padding, Size};
 
 /// A set of size constraints for layouting.
 #[derive(Debug, Clone, Copy)]
@@ -17,9 +17,6 @@ impl Limits {
     };
 
     /// Creates new [`Limits`] with the given minimum and maximum [`Size`].
-    ///
-    /// [`Limits`]: struct.Limits.html
-    /// [`Size`]: ../struct.Size.html
     pub const fn new(min: Size, max: Size) -> Limits {
         Limits {
             min,
@@ -29,32 +26,21 @@ impl Limits {
     }
 
     /// Returns the minimum [`Size`] of the [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
-    /// [`Size`]: ../struct.Size.html
     pub fn min(&self) -> Size {
         self.min
     }
 
     /// Returns the maximum [`Size`] of the [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
-    /// [`Size`]: ../struct.Size.html
     pub fn max(&self) -> Size {
         self.max
     }
 
     /// Returns the fill [`Size`] of the [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
-    /// [`Size`]: ../struct.Size.html
     pub fn fill(&self) -> Size {
         self.fill
     }
 
     /// Applies a width constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn width(mut self, width: Length) -> Limits {
         match width {
             Length::Shrink => {
@@ -77,8 +63,6 @@ impl Limits {
     }
 
     /// Applies a height constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn height(mut self, height: Length) -> Limits {
         match height {
             Length::Shrink => {
@@ -101,8 +85,6 @@ impl Limits {
     }
 
     /// Applies a minimum width constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn min_width(mut self, min_width: u32) -> Limits {
         self.min.width =
             self.min.width.max(min_width as f32).min(self.max.width);
@@ -111,8 +93,6 @@ impl Limits {
     }
 
     /// Applies a maximum width constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn max_width(mut self, max_width: u32) -> Limits {
         self.max.width =
             self.max.width.min(max_width as f32).max(self.min.width);
@@ -121,8 +101,6 @@ impl Limits {
     }
 
     /// Applies a minimum height constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn min_height(mut self, min_height: u32) -> Limits {
         self.min.height =
             self.min.height.max(min_height as f32).min(self.max.height);
@@ -131,8 +109,6 @@ impl Limits {
     }
 
     /// Applies a maximum height constraint to the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn max_height(mut self, max_height: u32) -> Limits {
         self.max.height =
             self.max.height.min(max_height as f32).max(self.min.height);
@@ -141,16 +117,14 @@ impl Limits {
     }
 
     /// Shrinks the current [`Limits`] to account for the given padding.
-    ///
-    /// [`Limits`]: struct.Limits.html
-    pub fn pad(&self, padding: f32) -> Limits {
-        self.shrink(Size::new(padding * 2.0, padding * 2.0))
+    pub fn pad(&self, padding: Padding) -> Limits {
+        self.shrink(Size::new(
+            padding.horizontal() as f32,
+            padding.vertical() as f32,
+        ))
     }
 
     /// Shrinks the current [`Limits`] by the given [`Size`].
-    ///
-    /// [`Limits`]: struct.Limits.html
-    /// [`Size`]: ../struct.Size.html
     pub fn shrink(&self, size: Size) -> Limits {
         let min = Size::new(
             (self.min().width - size.width).max(0.0),
@@ -171,8 +145,6 @@ impl Limits {
     }
 
     /// Removes the minimum width constraint for the current [`Limits`].
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn loose(&self) -> Limits {
         Limits {
             min: Size::ZERO,
@@ -183,8 +155,6 @@ impl Limits {
 
     /// Computes the resulting [`Size`] that fits the [`Limits`] given the
     /// intrinsic size of some content.
-    ///
-    /// [`Limits`]: struct.Limits.html
     pub fn resolve(&self, intrinsic_size: Size) -> Size {
         Size::new(
             intrinsic_size
diff --git a/native/src/layout/node.rs b/native/src/layout/node.rs
index a265c46a..d7666f31 100644
--- a/native/src/layout/node.rs
+++ b/native/src/layout/node.rs
@@ -9,17 +9,11 @@ pub struct Node {
 
 impl Node {
     /// Creates a new [`Node`] with the given [`Size`].
-    ///
-    /// [`Node`]: struct.Node.html
-    /// [`Size`]: ../struct.Size.html
     pub const fn new(size: Size) -> Self {
         Self::with_children(size, Vec::new())
     }
 
     /// Creates a new [`Node`] with the given [`Size`] and children.
-    ///
-    /// [`Node`]: struct.Node.html
-    /// [`Size`]: ../struct.Size.html
     pub const fn with_children(size: Size, children: Vec<Node>) -> Self {
         Node {
             bounds: Rectangle {
@@ -33,30 +27,21 @@ impl Node {
     }
 
     /// Returns the [`Size`] of the [`Node`].
-    ///
-    /// [`Node`]: struct.Node.html
-    /// [`Size`]: ../struct.Size.html
     pub fn size(&self) -> Size {
         Size::new(self.bounds.width, self.bounds.height)
     }
 
     /// Returns the bounds of the [`Node`].
-    ///
-    /// [`Node`]: struct.Node.html
     pub fn bounds(&self) -> Rectangle {
         self.bounds
     }
 
     /// Returns the children of the [`Node`].
-    ///
-    /// [`Node`]: struct.Node.html
     pub fn children(&self) -> &[Node] {
         &self.children
     }
 
     /// Aligns the [`Node`] in the given space.
-    ///
-    /// [`Node`]: struct.Node.html
     pub fn align(
         &mut self,
         horizontal_alignment: Align,
@@ -85,8 +70,6 @@ impl Node {
     }
 
     /// Moves the [`Node`] to the given position.
-    ///
-    /// [`Node`]: struct.Node.html
     pub fn move_to(&mut self, position: Point) {
         self.bounds.x = position.x;
         self.bounds.y = position.y;