Refactor Margin for fine grained control (#2727)

helix-term/src/commands/lsp.rs

@@ -287,10 +287,8 @@ pub fn code_action(cx: &mut Context) {
             });
             picker.move_down(); // pre-select the first item
 
-            let popup = Popup::new("code-action", picker).margin(helix_view::graphics::Margin {
-                vertical: 1,
-                horizontal: 1,
-            });
+            let popup =
+                Popup::new("code-action", picker).margin(helix_view::graphics::Margin::all(1));
             compositor.replace_or_push("code-action", popup);
         },
     )

helix-term/src/ui/info.rs

@@ -27,10 +27,7 @@ fn render(&mut self, viewport: Rect, surface: &mut Surface, cx: &mut Context) {
             .borders(Borders::ALL)
             .border_style(popup_style);
 
-        let margin = Margin {
-            vertical: 0,
-            horizontal: 1,
-        };
+        let margin = Margin::horizontal(1);
         let inner = block.inner(area).inner(&margin);
         block.render(area, surface);
 

helix-term/src/ui/markdown.rs

@@ -323,10 +323,7 @@ fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
             .wrap(Wrap { trim: false })
             .scroll((cx.scroll.unwrap_or_default() as u16, 0));
 
-        let margin = Margin {
-            vertical: 1,
-            horizontal: 1,
-        };
+        let margin = Margin::all(1);
         par.render(area.inner(&margin), surface);
     }
 

helix-term/src/ui/picker.rs

@@ -200,10 +200,7 @@ fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         // calculate the inner area inside the box
         let inner = block.inner(preview_area);
         // 1 column gap on either side
-        let margin = Margin {
-            vertical: 0,
-            horizontal: 1,
-        };
+        let margin = Margin::horizontal(1);
         let inner = inner.inner(&margin);
         block.render(preview_area, surface);
 

helix-term/src/ui/popup.rs

@@ -27,10 +27,7 @@ pub fn new(id: &'static str, contents: T) -> Self {
         Self {
             contents,
             position: None,
-            margin: Margin {
-                vertical: 0,
-                horizontal: 0,
-            },
+            margin: Margin::none(),
             size: (0, 0),
             child_size: (0, 0),
             scroll: 0,
@@ -163,8 +160,8 @@ fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
 
         self.child_size = (width, height);
         self.size = (
-            (width + self.margin.horizontal * 2).min(max_width),
-            (height + self.margin.vertical * 2).min(max_height),
+            (width + self.margin.width()).min(max_width),
+            (height + self.margin.height()).min(max_height),
         );
 
         // re-clamp scroll offset

helix-term/src/ui/prompt.rs

@@ -430,10 +430,7 @@ pub fn render_prompt(&self, area: Rect, surface: &mut Surface, cx: &mut Context)
                 .borders(Borders::ALL)
                 .border_style(background);
 
-            let inner = block.inner(area).inner(&Margin {
-                vertical: 0,
-                horizontal: 1,
-            });
+            let inner = block.inner(area).inner(&Margin::horizontal(1));
 
             block.render(area, surface);
             text.render(inner, surface, cx);

helix-tui/src/layout.rs

@@ -68,10 +68,7 @@ impl Default for Layout {
     fn default() -> Layout {
         Layout {
             direction: Direction::Vertical,
-            margin: Margin {
-                horizontal: 0,
-                vertical: 0,
-            },
+            margin: Margin::none(),
             constraints: Vec::new(),
         }
     }
@@ -87,20 +84,19 @@ pub fn constraints<C>(mut self, constraints: C) -> Layout
     }
 
     pub fn margin(mut self, margin: u16) -> Layout {
-        self.margin = Margin {
-            horizontal: margin,
-            vertical: margin,
-        };
+        self.margin = Margin::all(margin);
         self
     }
 
     pub fn horizontal_margin(mut self, horizontal: u16) -> Layout {
-        self.margin.horizontal = horizontal;
+        self.margin.left = horizontal;
+        self.margin.right = horizontal;
         self
     }
 
     pub fn vertical_margin(mut self, vertical: u16) -> Layout {
-        self.margin.vertical = vertical;
+        self.margin.top = vertical;
+        self.margin.bottom = vertical;
         self
     }
 

helix-view/src/graphics.rs

@@ -27,8 +27,61 @@ fn default() -> Self {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Margin {
-    pub vertical: u16,
-    pub horizontal: u16,
+    pub left: u16,
+    pub right: u16,
+    pub top: u16,
+    pub bottom: u16,
+}
+
+impl Margin {
+    pub fn none() -> Self {
+        Self {
+            left: 0,
+            right: 0,
+            top: 0,
+            bottom: 0,
+        }
+    }
+
+    /// Set uniform margin for all sides.
+    pub fn all(value: u16) -> Self {
+        Self {
+            left: value,
+            right: value,
+            top: value,
+            bottom: value,
+        }
+    }
+
+    /// Set the margin of left and right sides to specified value.
+    pub fn horizontal(value: u16) -> Self {
+        Self {
+            left: value,
+            right: value,
+            top: 0,
+            bottom: 0,
+        }
+    }
+
+    /// Set the margin of top and bottom sides to specified value.
+    pub fn vertical(value: u16) -> Self {
+        Self {
+            left: 0,
+            right: 0,
+            top: value,
+            bottom: value,
+        }
+    }
+
+    /// Get the total width of the margin (left + right)
+    pub fn width(&self) -> u16 {
+        self.left + self.right
+    }
+
+    /// Get the total height of the margin (top + bottom)
+    pub fn height(&self) -> u16 {
+        self.top + self.bottom
+    }
 }
 
 /// A simple rectangle used in the computation of the layout and to give widgets an hint about the
@@ -141,14 +194,14 @@ pub fn with_width(self, width: u16) -> Rect {
     }
 
     pub fn inner(self, margin: &Margin) -> Rect {
-        if self.width < 2 * margin.horizontal || self.height < 2 * margin.vertical {
+        if self.width < margin.width() || self.height < margin.height() {
             Rect::default()
         } else {
             Rect {
-                x: self.x + margin.horizontal,
-                y: self.y + margin.vertical,
-                width: self.width - 2 * margin.horizontal,
-                height: self.height - 2 * margin.vertical,
+                x: self.x + margin.left,
+                y: self.y + margin.top,
+                width: self.width - margin.width(),
+                height: self.height - margin.height(),
             }
         }
     }