feat: allow negative sizes (closes #1040) (#1043)

* feat: allow negative sizes (closes #1040)

* chore: generate completions & manpage

---------

Co-authored-by: Skim bot <skim-bot@skim-rs.github.io>

Author: LoricAndre

.github/dependabot.yml

@@ -12,5 +12,7 @@ updates:
     schedule:
       interval: monthly
     commit-message:
-      prefix: chore(ci/deps)
-      prefix-development: chore(ci/dev-deps)
+      prefix: chore(deps)
+      prefix-development: chore(dev-deps)
+    exclude-paths:
+      - .github/workflows/release.yml

flake.lock

@@ -319,7 +319,7 @@ Shorthand for reverse layout
 \fB\-\-height\fR \fI<HEIGHT>\fR [default: 100%]
 Height of skim\*(Aqs window
 
-Can either be a row count or a percentage
+Can either be a row count or a percentage A negative row count will use term height \- value as height
 .TP
 \fB\-\-no\-height\fR
 Disable height (force full screen)
@@ -506,13 +506,13 @@ ls \-l | sk \-\-preview="echo user={3} when={\-4..\-2}; cat {\-1}" \-\-header\-l
 \fB\-\-preview\-window\fR \fI<PREVIEW_WINDOW>\fR [default: right:50%]
 Preview window layout
 
-Format: [up|down|left|right][:SIZE[%]][:hidden][:[no]wrap][:[no]pty][:+SCROLL[\-OFFSET]]
+Format: [up|down|left|right][:SIZE][:hidden][:[no]wrap][:[no]pty][:+SCROLL[\-OFFSET]]
 
 Determine  the  layout of the preview window. If the argument ends with: hidden, the preview window will be hidden by default until toggle\-preview action is triggered. Long lines are truncated by default. Line wrap can be enabled with :wrap flag. For more interactive commands or previews that draw complex interfaces, the preview can use a PTY with the :pty flag.
 
 Note: the preview will run in a PTY (interactive session) on linux and when wrap is unset
 
-If size is given as 0, preview window will not be visible, but sk will still execute the command in the background.
+SIZE can be either: \- 0, which will hide the preview window \- A positive size (eg 20) \- A percentage of the total size (eg 50%) \- A negative size, which will set the size of everything but the preview to that value
 
 +SCROLL[\-OFFSET] determines the initial scroll offset of the preview window. SCROLL can be either a  numeric  integer or  a  single\-field index expression that refers to a numeric integer. The optional \-OFFSET part is for adjusting the base offset so that you can see the text above it. It should be given as a numeric integer (\-INTEGER), or as a denom‐ inator form (\-/INTEGER) for specifying a fraction of the preview window height.
 

man/man1/sk.1

@@ -405,7 +405,11 @@ pub struct SkimOptions {
     /// Height of skim's window
     ///
     /// Can either be a row count or a percentage
-    #[cfg_attr(feature = "cli", arg(long, default_value = "100%", help_heading = "Layout"))]
+    /// A negative row count will use `term height` - `value` as height
+    #[cfg_attr(
+        feature = "cli",
+        arg(long, default_value = "100%", help_heading = "Layout", allow_hyphen_values = true)
+    )]
     pub height: String,
 
     /// Disable height (force full screen)
@@ -630,7 +634,7 @@ pub struct SkimOptions {
 
     /// Preview window layout
     ///
-    /// Format: [up|down|left|right][:SIZE[%]][:hidden][:[no]wrap][:[no]pty][:+SCROLL[-OFFSET]]
+    /// Format: [up|down|left|right][:SIZE][:hidden][:[no]wrap][:[no]pty][:+SCROLL[-OFFSET]]
     ///
     /// Determine  the  layout of the preview window. If the argument ends with: hidden, the preview window will be hidden by
     /// default until toggle-preview action is triggered. Long lines are truncated by default.
@@ -639,7 +643,11 @@ pub struct SkimOptions {
     ///
     /// Note: the preview will run in a PTY (interactive session) on linux and when `wrap` is unset
     ///
-    /// If size is given as 0, preview window will not be visible, but sk will still execute the command in the background.
+    /// SIZE can be either:
+    ///     - `0`, which will hide the preview window
+    ///     - A positive size (eg `20`)
+    ///     - A percentage of the total size (eg `50%`)
+    ///     - A negative size, which will set the size of everything but the preview to that value
     ///
     /// +SCROLL[-OFFSET] determines the initial scroll offset of the preview window. SCROLL can be either a  numeric  integer
     /// or  a  single-field index expression that refers to a numeric integer. The optional -OFFSET part is for adjusting the

src/options.rs

@@ -16,13 +16,14 @@ pub(super) struct ZellijPopup {
 fn middle_coord(size: Size, var: &str) -> Size {
     match size {
         Size::Percent(p) => Size::Percent(100u16.saturating_sub(p) / 2),
-        Size::Fixed(cols) => Size::Fixed(
+        Size::Fixed(cells) => Size::Fixed(
             std::env::var(var)
                 .map(|s| s.parse().unwrap_or(80))
                 .unwrap_or(80u16)
-                .saturating_sub(cols)
+                .saturating_sub(cells)
                 / 2,
         ),
+        Size::Neg(cells) => Size::Fixed(cells / 2),
     }
 }
 
@@ -35,6 +36,7 @@ fn align_end_coord(size: Size, var: &str) -> Size {
                 .unwrap_or(80u16)
                 .saturating_sub(cols),
         ),
+        Size::Neg(cells) => Size::Fixed(cells),
     }
 }
 

src/popup/zellij.rs

@@ -406,6 +406,7 @@ impl App {
         }
     }
 
+    #[allow(clippy::too_many_lines)]
     fn run_preview<B: Backend>(&mut self, tui: &mut Tui<B>) -> Result<()>
     where
         B::Error: Send + Sync + 'static,
@@ -468,12 +469,14 @@ impl App {
                     // Apply position offsets
                     let v_scroll = match preview_position.v_scroll {
                         crate::tui::Size::Fixed(n) => n,
+                        crate::tui::Size::Neg(n) => self.preview.rows.saturating_sub(n),
                         crate::tui::Size::Percent(p) => {
                             u16::try_from(u32::from(self.preview.rows) * u32::from(p) / 100).unwrap_or(u16::MAX)
                         }
                     };
                     let v_offset = match preview_position.v_offset {
                         crate::tui::Size::Fixed(n) => n,
+                        crate::tui::Size::Neg(n) => self.preview.rows.saturating_sub(n),
                         crate::tui::Size::Percent(p) => {
                             u16::try_from(u32::from(self.preview.rows) * u32::from(p) / 100).unwrap_or(u16::MAX)
                         }
@@ -483,12 +486,14 @@ impl App {
 
                     let h_scroll = match preview_position.h_scroll {
                         crate::tui::Size::Fixed(n) => n,
+                        crate::tui::Size::Neg(n) => self.preview.cols.saturating_sub(n),
                         crate::tui::Size::Percent(p) => {
                             u16::try_from(u32::from(self.preview.cols) * u32::from(p) / 100).unwrap_or(u16::MAX)
                         }
                     };
                     let h_offset = match preview_position.h_offset {
                         crate::tui::Size::Fixed(n) => n,
+                        crate::tui::Size::Neg(n) => self.preview.cols.saturating_sub(n),
                         crate::tui::Size::Percent(p) => {
                             u16::try_from(u32::from(self.preview.cols) * u32::from(p) / 100).unwrap_or(u16::MAX)
                         }

src/tui/app.rs

@@ -75,6 +75,7 @@ where
             Size::Percent(100) => None,
             Size::Fixed(lines) => Some(lines),
             Size::Percent(p) => Some(term_height * p / 100),
+            Size::Neg(lines) => Some(term_height.saturating_sub(lines)),
         };
 
         let viewport = if let Some(mut height) = lines {

src/tui/backend.rs

@@ -92,22 +92,23 @@ impl LayoutTemplate {
         };
 
         // Preview placement and layout.
-        let preview_visible =
-            (options.preview.is_some() || options.preview_fn.is_some()) && !options.preview_window.hidden;
+        let preview_visible = (options.preview.is_some() || options.preview_fn.is_some())
+            && !options.preview_window.hidden
+            && !matches!(options.preview_window.size, Size::Fixed(0));
 
         let (preview_placement, preview_layout) = if preview_visible {
-            let pc = size_to_constraint(options.preview_window.size);
+            let (preview_c, rest_c) = size_to_constraint(options.preview_window.size);
             let placement = match options.preview_window.direction {
                 Direction::Left => PreviewPlacement::Left,
                 Direction::Right => PreviewPlacement::Right,
                 Direction::Up => PreviewPlacement::Up,
                 Direction::Down => PreviewPlacement::Down,
             };
             let layout = match placement {
-                PreviewPlacement::Left => Layout::new(RatatuiDirection::Horizontal, [pc, Constraint::Fill(1)]),
-                PreviewPlacement::Right => Layout::new(RatatuiDirection::Horizontal, [Constraint::Fill(1), pc]),
-                PreviewPlacement::Up => Layout::new(RatatuiDirection::Vertical, [pc, Constraint::Fill(1)]),
-                PreviewPlacement::Down => Layout::new(RatatuiDirection::Vertical, [Constraint::Fill(1), pc]),
+                PreviewPlacement::Left => Layout::new(RatatuiDirection::Horizontal, [preview_c, rest_c]),
+                PreviewPlacement::Right => Layout::new(RatatuiDirection::Horizontal, [rest_c, preview_c]),
+                PreviewPlacement::Up => Layout::new(RatatuiDirection::Vertical, [preview_c, rest_c]),
+                PreviewPlacement::Down => Layout::new(RatatuiDirection::Vertical, [rest_c, preview_c]),
                 PreviewPlacement::None => unreachable!(),
             };
             (placement, Some(layout))
@@ -237,10 +238,11 @@ impl AppLayout {
 // Helper
 // ---------------------------------------------------------------------------
 
-fn size_to_constraint(size: Size) -> Constraint {
+fn size_to_constraint(size: Size) -> (Constraint, Constraint) {
     match size {
-        Size::Fixed(n) => Constraint::Length(n),
-        Size::Percent(p) => Constraint::Percentage(p),
+        Size::Fixed(n) => (Constraint::Length(n), Constraint::Fill(1)),
+        Size::Percent(p) => (Constraint::Percentage(p), Constraint::Fill(1)),
+        Size::Neg(n) => (Constraint::Fill(1), Constraint::Length(n)),
     }
 }
 

src/tui/layout.rs

@@ -46,6 +46,8 @@ pub enum Size {
     Percent(u16),
     /// Fixed size in terminal cells
     Fixed(u16),
+    /// Negative size is substracted from term height
+    Neg(u16),
 }
 
 /// Direction for movement or layout
@@ -99,6 +101,11 @@ impl TryFrom<&str> for Size {
                 return Err(SizeParseError::InvalidPercent(percent));
             }
             Ok(Self::Percent(percent))
+        } else if let Some(neg) = value.strip_prefix('-') {
+            Ok(Self::Neg(
+                neg.parse::<u16>()
+                    .map_err(|e| SizeParseError::ParseError(value.to_string(), e))?,
+            ))
         } else {
             Ok(Self::Fixed(
                 value
@@ -120,6 +127,7 @@ impl std::fmt::Display for Size {
         match self {
             Self::Percent(p) => f.write_fmt(format_args!("{p}%")),
             Self::Fixed(s) => f.write_fmt(format_args!("{s}")),
+            Self::Neg(s) => f.write_fmt(format_args!("-{s}")),
         }
     }
 }
@@ -183,11 +191,7 @@ mod size_test {
     }
     #[test]
     fn fixed_neg() {
-        let SizeParseError::ParseError(err_value, internal_error) = Size::try_from("-10").unwrap_err() else {
-            panic!();
-        };
-        assert_eq!(internal_error.kind(), &IntErrorKind::InvalidDigit);
-        assert_eq!(err_value, String::from("-10"));
+        assert_eq!(Size::try_from("-10"), Ok(Size::Neg(10)));
     }
     #[test]
     fn percent_neg() {

src/tui/mod.rs

@@ -101,6 +101,10 @@ impl Preview {
                 // Result is at most dimension (a u16), so truncation cannot occur.
                 u16::try_from(u32::from(dimension) * u32::from(p) / 100).unwrap_or(u16::MAX)
             }
+            super::Size::Neg(n) => {
+                let dimension = if is_vertical { self.rows } else { self.cols };
+                dimension.saturating_sub(n)
+            }
         }
     }