Fix conflicts

core/src/inner.rs

@@ -21,14 +21,14 @@ pub fn get_tabs(validate: bool) -> Vec<Tab> {
     });
 
     let tabs: Vec<Tab> = tabs
-        .map(|(TabEntry { name, data }, directory)| {
+        .map(|(TabEntry { name, data, multi_selectable }, directory)| {
             let mut tree = Tree::new(ListNode {
                 name: "root".to_string(),
                 command: Command::None,
             });
             let mut root = tree.root_mut();
             create_directory(data, &mut root, &directory);
-            Tab { name, tree }
+            Tab { name, tree, multi_selectable }
         })
         .collect();
 
@@ -47,6 +47,12 @@ struct TabList {
 struct TabEntry {
     name: String,
     data: Vec<Entry>,
+    #[serde(default = "default_multi_selectable")]
+    multi_selectable: bool,
+}
+
+fn default_multi_selectable() -> bool {
+    true
 }
 
 #[derive(Deserialize)]

core/src/lib.rs

@@ -16,6 +16,7 @@ pub enum Command {
 pub struct Tab {
     pub name: String,
     pub tree: Tree<ListNode>,
+    pub multi_selectable: bool,
 }
 
 #[derive(Clone, Hash, Eq, PartialEq)]

tabs/utils/tab_data.toml

@@ -1,4 +1,5 @@
 name = "Utilities"
+multi_selectable = false
 
 [[data]]
 name = "WiFi Manager"

tui/src/hint.rs

@@ -139,6 +139,10 @@ pub fn draw_shortcuts(state: &AppState, frame: &mut Frame, area: Rect) {
             hints.push(Shortcut::new(vec!["j", "Down"], "Select item below"));
             hints.push(Shortcut::new(vec!["t"], "Next theme"));
             hints.push(Shortcut::new(vec!["T"], "Previous theme"));
+            if state.is_current_tab_multi_selectable() {
+                hints.push(Shortcut::new(vec!["v"], "Toggle multi-selection mode"));
+                hints.push(Shortcut::new(vec!["Space"], "Select multiple commands"));
+            }
             ShortcutList {
                 scope_name: "Item list",
                 hints,

tui/src/running_command.rs

@@ -136,25 +136,31 @@ impl FloatContent for RunningCommand {
 }
 
 impl RunningCommand {
-    pub fn new(command: Command) -> Self {
+    pub fn new(commands: Vec<Command>) -> Self {
         let pty_system = NativePtySystem::default();
 
-        // Build the command based on the provided Command enum variant
-        let mut cmd = CommandBuilder::new("sh");
-        match command {
-            Command::Raw(prompt) => {
-                cmd.arg("-c");
-                cmd.arg(prompt);
-            }
-            Command::LocalFile(file) => {
-                cmd.arg(&file);
-                if let Some(parent) = file.parent() {
-                    cmd.cwd(parent);
+        // Create a command to execute all the selected commands
+        let mut cmd: CommandBuilder = CommandBuilder::new("sh");
+        cmd.arg("-c");
+
+        // Initialize an empty string to hold the merged commands
+        // All the merged commands are passed as a single argument to reduce the overhead of rebuilding the command arguments for each and every command
+        let mut script = String::new();
+        for command in commands {
+            match command {
+                Command::Raw(prompt) => script.push_str(&format!("{}\n", prompt)), // Merge raw commands
+                Command::LocalFile(file) => {
+                    if let Some(parent) = file.parent() {
+                        script.push_str(&format!("cd {}\n", parent.display())); // Merge local file path
+                    }
+                    script.push_str(&format!("sh {}\n", file.display()));
                 }
+                Command::None => panic!("Command::None was treated as a command"),
             }
-            Command::None => panic!("Command::None was treated as a command"),
         }
 
+        cmd.arg(script);
+
         // Open a pseudo-terminal with initial size
         let pair = pty_system
             .openpty(PtySize {

tui/src/state.rs

@@ -33,6 +33,8 @@ pub struct AppState {
     /// widget
     selection: ListState,
     filter: Filter,
+    multi_select: bool,              // This keeps track of Multi select toggle
+    selected_commands: Vec<Command>, // This field is to store selected commands
 }
 
 pub enum Focus {
@@ -60,6 +62,8 @@ impl AppState {
             visit_stack: vec![root_id],
             selection: ListState::default().with_selected(Some(0)),
             filter: Filter::new(),
+            multi_select: false,
+            selected_commands: Vec::new(), // Initialize with an empty vector
         };
         state.update_items();
         state
@@ -154,12 +158,29 @@ impl AppState {
             |ListEntry {
                  node, has_children, ..
              }| {
+                let is_selected = self.selected_commands.contains(&node.command);
+                let (indicator, style) = if is_selected {
+                    (self.theme.multi_select_icon(), Style::default().bold())
+                } else {
+                    ("", Style::new())
+                };
                 if *has_children {
-                    Line::from(format!("{}  {}", self.theme.dir_icon(), node.name))
-                        .style(self.theme.dir_color())
+                    Line::from(format!(
+                        "{}  {} {}",
+                        self.theme.dir_icon(),
+                        node.name,
+                        indicator
+                    ))
+                    .style(self.theme.dir_color())
                 } else {
-                    Line::from(format!("{}  {}", self.theme.cmd_icon(), node.name))
-                        .style(self.theme.cmd_color())
+                    Line::from(format!(
+                        "{}  {} {}",
+                        self.theme.cmd_icon(),
+                        node.name,
+                        indicator
+                    ))
+                    .style(self.theme.cmd_color())
+                    .patch_style(style)
                 }
             },
         ));
@@ -171,11 +192,15 @@ impl AppState {
             } else {
                 Style::new()
             })
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .title(format!("Linux Toolbox - {}", env!("BUILD_DATE"))),
-            )
+            .block(Block::default().borders(Borders::ALL).title(format!(
+                "Linux Toolbox - {} {}",
+                env!("BUILD_DATE"),
+                if self.multi_select {
+                    "[Multi-Select]"
+                } else {
+                    ""
+                }
+            )))
             .scroll_padding(1);
         frame.render_stateful_widget(list, chunks[1], &mut self.selection);
 
@@ -233,18 +258,47 @@ impl AppState {
                 KeyCode::Tab => self.focus = Focus::TabList,
                 KeyCode::Char('t') => self.theme.next(),
                 KeyCode::Char('T') => self.theme.prev(),
+                KeyCode::Char('v') | KeyCode::Char('V') => self.toggle_multi_select(),
+                KeyCode::Char(' ') if self.multi_select => self.toggle_selection(),
                 _ => {}
             },
             _ => {}
         };
         true
     }
+    fn toggle_multi_select(&mut self) {
+        if self.is_current_tab_multi_selectable() {
+            self.multi_select = !self.multi_select;
+            if !self.multi_select {
+                self.selected_commands.clear();
+            }
+        }
+    }
+    fn toggle_selection(&mut self) {
+        if let Some(command) = self.get_selected_command() {
+            if self.selected_commands.contains(&command) {
+                self.selected_commands.retain(|c| c != &command);
+            } else {
+                self.selected_commands.push(command);
+            }
+        }
+    }
+    pub fn is_current_tab_multi_selectable(&self) -> bool {
+        let index = self.current_tab.selected().unwrap_or(0);
+        self.tabs
+            .get(index)
+            .map_or(false, |tab| tab.multi_selectable)
+    }
     fn update_items(&mut self) {
         self.filter.update_items(
             &self.tabs,
             self.current_tab.selected().unwrap(),
             *self.visit_stack.last().unwrap(),
         );
+        if !self.is_current_tab_multi_selectable() {
+            self.multi_select = false;
+            self.selected_commands.clear();
+        }
     }
     /// Checks ehther the current tree node is the root node (can we go up the tree or no)
     /// Returns `true` if we can't go up the tree (we are at the tree root)
@@ -342,9 +396,15 @@ impl AppState {
         }
     }
     fn handle_enter(&mut self) {
-        if let Some(cmd) = self.get_selected_command() {
-            let command = RunningCommand::new(cmd);
+        if self.selected_commands.is_empty() {
+            // If no commands are selected, run the currently by pushing them into vector
+            if let Some(cmd) = self.get_selected_command() {
+                self.selected_commands.push(cmd);
+            }
+
+            let command = RunningCommand::new(self.selected_commands.clone());
             self.spawn_float(command, 80, 80);
+            self.selected_commands.clear();
         } else {
             self.go_to_selected_dir();
         }

tui/src/theme.rs

@@ -56,6 +56,13 @@ impl Theme {
         }
     }
 
+    pub fn multi_select_icon(&self) -> &'static str {
+        match self {
+            Theme::Default => "",
+            Theme::Compatible => "*",
+        }
+    }
+
     pub fn success_color(&self) -> Color {
         match self {
             Theme::Default => Color::Rgb(199, 55, 44),