feat(ui): swap layouts and stacked panes (#2167)

* relayout working with hard coded layout

* work

* refactor(layout): PaneLayout => TiledPaneLayout

* tests passing

* tests passing

* tests passing

* stacked panes and passing tests

* tests for stacked panes

* refactor(panes): stacked panes

* fix: focusing into stacked panes from the left/right

* fix(layouts): handle stacked layouts in the middle of the screen

* fix(pane-stack): focus correctly when coming to stack from above/below

* fix(stacked-panes): resize stack

* fix(stacked-panes): focus with mouse

* fix(stacked-panes): focus next pane

* fix(layout-applier): sane focus order

* fix(stacked-panes): better titles for one-liners

* fix(stacked-panes): handle moving pane location in stack

* fix(relayout): properly calculate display area

* fix(relayout): properly calculate rounding errors

* fix(stacked-panes): properly handle closing a pane near a stack

* fix(swap-layouts): adjust swap layout sort order

* feat(swap-layouts): ui + ux

* fix(swap-layouts): include base layout

* refactor(layout): remove unused method

* fix(swap-layouts): respect pane contents and focus

* work

* fix(swap-layouts): load swap layouts from external file

* fix(swap-layouts): properly truncate layout children

* fix(stacked-panes): allow stacked panes to become fullscreen

* fix(swap-layouts): work with multiple tabs

* fix(swap-layouts): embed/eject panes properly with auto-layout

* fix(stacked-panes): close last pane in stack

* fix(stacked-panes): move focus for all clients in stack

* fix(floating-panes): set layout damaged when moving panes

* fix(relayout): move out of unfitting layout when resizing whole tab

* fix(ui): background color for swap layout indicator

* fix(keybinds): add switch next layout in tmux

* fix(ui): swap layout indication in compact layout

* fix(compact): correct swap constraint

* fix(tests): tmux swap config shortcut

* fix(resizes): cache resizes so as not to confuse panes (eg. vim) with multiple resizes that it debounces weirdly

* feat(cli): dump swap layouts

* fix(ui): stacked panes without pane frames

* fix(ux): move pane forward/backwards also with floating panes

* refactor(lint): remove unused stuff

* refactor(tab): move swap layouts to separate file

* style(fmt): rustfmt

* style(fmt): rustfmt

* refactor(panes): various cleanups

* chore(deps): upgrade termwiz to get alt left-bracket

* fix(assets): merge conflicts of binary files

* style(fmt): rustfmt

* style(clippy): no thank you!

* chore(repo): remove garbage file

2 files changed, 100 insertions, 0 deletions

diff --git a/default-plugins/compact-bar/src/line.rs b/default-plugins/compact-bar/src/line.rs
index 16d64d07..6bcbab18 100644
--- a/default-plugins/compact-bar/src/line.rs
+++ b/default-plugins/compact-bar/src/line.rs
@@ -256,6 +256,8 @@ pub fn tab_line(
     palette: Palette,
     capabilities: PluginCapabilities,
     mode: InputMode,
+    active_swap_layout_name: &Option<String>,
+    is_swap_layout_dirty: bool,
 ) -> Vec<LinePart> {
     let mut tabs_after_active = all_tabs.split_off(active_tab_index);
     let mut tabs_before_active = all_tabs;
@@ -283,5 +285,97 @@ pub fn tab_line(
         capabilities,
     );
     prefix.append(&mut tabs_to_render);
+
+    let current_title_len = get_current_title_len(&prefix);
+    if current_title_len < cols {
+        let mut remaining_space = cols - current_title_len;
+        if let Some(swap_layout_status) = swap_layout_status(
+            remaining_space,
+            active_swap_layout_name,
+            is_swap_layout_dirty,
+            mode,
+            &palette,
+            tab_separator(capabilities),
+        ) {
+            remaining_space -= swap_layout_status.len;
+            let mut buffer = String::new();
+            for _ in 0..remaining_space {
+                buffer.push_str(&style!(palette.black, palette.black).paint(" ").to_string());
+            }
+            prefix.push(LinePart {
+                part: buffer,
+                len: remaining_space,
+                tab_index: None,
+            });
+            prefix.push(swap_layout_status);
+        }
+    }
+
     prefix
 }
+
+fn swap_layout_status(
+    max_len: usize,
+    swap_layout_name: &Option<String>,
+    is_swap_layout_damaged: bool,
+    input_mode: InputMode,
+    palette: &Palette,
+    separator: &str,
+) -> Option<LinePart> {
+    match swap_layout_name {
+        Some(swap_layout_name) => {
+            let mut swap_layout_name = format!(" {} ", swap_layout_name);
+            swap_layout_name.make_ascii_uppercase();
+            let swap_layout_name_len = swap_layout_name.len() + 3;
+
+            let (prefix_separator, swap_layout_name, suffix_separator) =
+                if input_mode == InputMode::Locked {
+                    (
+                        style!(palette.black, palette.fg).paint(separator),
+                        style!(palette.black, palette.fg)
+                            .italic()
+                            .paint(&swap_layout_name),
+                        style!(palette.fg, palette.black).paint(separator),
+                    )
+                } else if is_swap_layout_damaged {
+                    (
+                        style!(palette.black, palette.fg).paint(separator),
+                        style!(palette.black, palette.fg)
+                            .bold()
+                            .paint(&swap_layout_name),
+                        style!(palette.fg, palette.black).paint(separator),
+                    )
+                } else {
+                    (
+                        style!(palette.black, palette.green).paint(separator),
+                        style!(palette.black, palette.green)
+                            .bold()
+                            .paint(&swap_layout_name),
+                        style!(palette.green, palette.black).paint(separator),
+                    )
+                };
+            let swap_layout_indicator = format!(
+                "{}{}{}",
+                prefix_separator, swap_layout_name, suffix_separator
+            );
+            let (part, full_len) = (format!("{}", swap_layout_indicator), swap_layout_name_len);
+            let short_len = swap_layout_name_len + 1; // 1 is the space between
+            if full_len <= max_len {
+                Some(LinePart {
+                    part,
+                    len: full_len,
+                    tab_index: None,
+                })
+            } else if short_len <= max_len && input_mode != InputMode::Locked {
+                Some(LinePart {
+                    part: swap_layout_indicator,
+                    len: short_len,
+                    tab_index: None,
+                })
+            } else {
+                None
+            }
+        },
+        None => None,
+    }
+}
diff --git a/default-plugins/compact-bar/src/main.rs b/default-plugins/compact-bar/src/main.rs
index c6ce9bbc..71652f0f 100644
--- a/default-plugins/compact-bar/src/main.rs
+++ b/default-plugins/compact-bar/src/main.rs
@@ -92,6 +92,8 @@ impl ZellijPlugin for State {
         }
         let mut all_tabs: Vec<LinePart> = vec![];
         let mut active_tab_index = 0;
+        let mut active_swap_layout_name = None;
+        let mut is_swap_layout_dirty = false;
         let mut is_alternate_tab = false;
         for t in &mut self.tabs {
             let mut tabname = t.name.clone();
@@ -102,6 +104,8 @@ impl ZellijPlugin for State {
                 active_tab_index = t.position;
             } else if t.active {
                 active_tab_index = t.position;
+                is_swap_layout_dirty = t.is_swap_layout_dirty;
+                active_swap_layout_name = t.active_swap_layout_name.clone();
             }
             let tab = tab_style(
                 tabname,
@@ -121,6 +125,8 @@ impl ZellijPlugin for State {
             self.mode_info.style.colors,
             self.mode_info.capabilities,
             self.mode_info.mode,
+            &active_swap_layout_name,
+            is_swap_layout_dirty,
         );
         let mut s = String::new();
         let mut len_cnt = 0;