feat: allow multiple formats in single tabs widget format

1 files changed, 60 insertions, 50 deletions

diff --git a/src/widgets/tabs.rs b/src/widgets/tabs.rs
index d302cd7..a5745ac 100644
--- a/src/widgets/tabs.rs
+++ b/src/widgets/tabs.rs
@@ -7,59 +7,51 @@ use crate::render::FormattedPart;
 use super::widget::Widget;
 
 pub struct TabsWidget {
-    active_tab_format: FormattedPart,
-    active_tab_fullscreen_format: FormattedPart,
-    active_tab_sync_format: FormattedPart,
-    normal_tab_format: FormattedPart,
-    normal_tab_fullscreen_format: FormattedPart,
-    normal_tab_sync_format: FormattedPart,
+    active_tab_format: Vec<FormattedPart>,
+    active_tab_fullscreen_format: Vec<FormattedPart>,
+    active_tab_sync_format: Vec<FormattedPart>,
+    normal_tab_format: Vec<FormattedPart>,
+    normal_tab_fullscreen_format: Vec<FormattedPart>,
+    normal_tab_sync_format: Vec<FormattedPart>,
 }
 
 impl TabsWidget {
     pub fn new(config: BTreeMap<String, String>) -> Self {
-        let mut normal_tab_format_string = "";
+        let mut normal_tab_format: Vec<FormattedPart> = Vec::new();
         if let Some(form) = config.get("tab_normal") {
-            normal_tab_format_string = form;
+            normal_tab_format = get_formatters(form.to_string());
         }
 
-        let normal_tab_fullscreen_format =
-            FormattedPart::from_format_string(match config.get("tab_normal_fullscreen") {
-                Some(form) => form.to_string(),
-                None => normal_tab_format_string.to_string(),
-            });
+        let normal_tab_fullscreen_format = match config.get("tab_normal_fullscreen") {
+            Some(form) => get_formatters(form.to_string()),
+            None => normal_tab_format.clone(),
+        };
 
-        let normal_tab_sync_format =
-            FormattedPart::from_format_string(match config.get("tab_normal_sync") {
-                Some(form) => form.to_string(),
-                None => normal_tab_format_string.to_string(),
-            });
+        let normal_tab_sync_format = match config.get("tab_normal_sync") {
+            Some(form) => get_formatters(form.to_string()),
+            None => normal_tab_format.clone(),
+        };
 
-        let mut active_tab_format_string = normal_tab_format_string.clone();
+        let mut active_tab_format = normal_tab_format.clone();
         if let Some(form) = config.get("tab_active") {
-            active_tab_format_string = form;
+            active_tab_format = get_formatters(form.to_string());
         }
 
-        let active_tab_fullscreen_format =
-            FormattedPart::from_format_string(match config.get("tab_active_fullscreen") {
-                Some(form) => form.to_string(),
-                None => active_tab_format_string.to_string(),
-            });
+        let active_tab_fullscreen_format = match config.get("tab_active_fullscreen") {
+            Some(form) => get_formatters(form.to_string()),
+            None => active_tab_format.clone(),
+        };
 
-        let active_tab_sync_format =
-            FormattedPart::from_format_string(match config.get("tab_active_sync") {
-                Some(form) => form.to_string(),
-                None => active_tab_format_string.to_string(),
-            });
+        let active_tab_sync_format = match config.get("tab_active_sync") {
+            Some(form) => get_formatters(form.to_string()),
+            None => active_tab_format.clone(),
+        };
 
         Self {
-            normal_tab_format: FormattedPart::from_format_string(
-                normal_tab_format_string.to_string(),
-            ),
+            normal_tab_format,
             normal_tab_fullscreen_format,
             normal_tab_sync_format,
-            active_tab_format: FormattedPart::from_format_string(
-                active_tab_format_string.to_string(),
-            ),
+            active_tab_format,
             active_tab_fullscreen_format,
             active_tab_sync_format,
         }
@@ -71,10 +63,9 @@ impl Widget for TabsWidget {
         let mut output = "".to_string();
 
         for tab in state.tabs {
-            let formatter = self.select_format(tab.clone());
             let content = self.render_tab(tab);
 
-            output = format!("{}{}", output, formatter.format_string(content),);
+            output = format!("{}{}", output, content);
         }
 
         output
@@ -86,16 +77,16 @@ impl Widget for TabsWidget {
         let mut offset = 0;
         let mut index = 1;
         for tab in state.tabs {
-            let content = self.render_tab(tab);
+            let content = strip_ansi_escapes::strip_str(self.render_tab(tab));
 
-            if pos > offset && pos < offset + content.len() {
+            if pos > offset && pos < offset + content.chars().count() {
                 switch_tab_to(index);
 
                 break;
             }
 
             index += 1;
-            offset += content.len();
+            offset += content.chars().count();
 
             output = format!("{}{}", output, content);
         }
@@ -103,7 +94,7 @@ impl Widget for TabsWidget {
 }
 
 impl TabsWidget {
-    fn select_format(&self, info: TabInfo) -> FormattedPart {
+    fn select_format(&self, info: TabInfo) -> Vec<FormattedPart> {
         if info.active && info.is_fullscreen_active {
             return self.active_tab_fullscreen_format.clone();
         }
@@ -128,17 +119,36 @@ impl TabsWidget {
     }
 
     fn render_tab(&self, tab: TabInfo) -> String {
-        let formatter = self.select_format(tab.clone());
+        let formatters = self.select_format(tab.clone());
+        let mut output = "".to_string();
 
-        let mut content = formatter.content.clone();
-        if content.contains("{name}") {
-            content = content.replace("{name}", tab.name.as_str());
-        }
+        for f in formatters.iter() {
+            let mut content = f.content.clone();
+
+            if content.contains("{name}") {
+                content = content.replace("{name}", tab.name.as_str());
+            }
+
+            if content.contains("{index}") {
+                content = content.replace("{index}", (tab.position + 1).to_string().as_str());
+            }
 
-        if content.contains("{index}") {
-            content = content.replace("{index}", (tab.position + 1).to_string().as_str());
+            output = format!("{}{}", output, f.format_string(content));
         }
 
-        content
+        output.to_string()
     }
 }
+
+fn get_formatters(config: String) -> Vec<FormattedPart> {
+    let mut output = Vec::new();
+
+    let color_parts = config.split("#[");
+    for color_part in color_parts {
+        let part = FormattedPart::from_format_string(color_part.to_string());
+
+        output.push(part);
+    }
+
+    output
+}