Added Groups

src/main.rs

@@ -38,6 +38,9 @@ enum Command {
     #[clap(about = "Focus to another workspace on the same output")]
     Focus(FocusAction),
 
+    #[clap(about = "Focus to output")]
+    FocusOutput(FocusAction),
+
     #[clap(about = "Focus to another workspace on all the outputs")]
     FocusAllOutputs(FocusAction),
 
@@ -47,6 +50,12 @@ enum Command {
     #[clap(about = "Move the focused container to the previous output")]
     PrevOutput,
 
+    #[clap(about = "Move the focused container to the next group")]
+    NextGroup,
+
+    #[clap(about = "Move the focused container to the previous group")]
+    PrevGroup,
+
     #[clap(about = "Rearrange already opened workspaces")]
     RearrangeWorkspaces,
 }
@@ -195,7 +204,7 @@ fn get_current_output_index(stream: &UnixStream) -> usize {
     let outputs = get_outputs(stream);
 
     match outputs.iter().position(|x| x.focused) {
-        Some(i) => i,
+        Some(i) => i + 1,
         None => panic!("WTF! No focused output???"),
     }
 }
@@ -211,22 +220,200 @@ fn get_current_output_name(stream: &UnixStream) -> String {
     focused_output_index.to_string()
 }
 
+fn get_current_workspace(stream: &UnixStream) -> Workspace {
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+    workspaces
+        .into_iter()
+        .find(|w| w.visible && outputs.iter().find(|o| o.name == w.output).unwrap().focused)
+        .unwrap()
+}
+
 fn move_container_to_workspace(stream: &UnixStream, workspace_index: usize) {
-    let mut cmd: String = "move container to workspace number ".to_string();
+    if workspace_index < 10 {
-    let full_ws_name = format!("{}{}", get_current_output_index(stream), workspace_index)
+        let mut cmd: String = "move container to workspace number ".to_string();
+        let full_ws_name = format!("{}{}", get_current_output_index(stream), workspace_index)
+            .parse::<i32>()
+            .unwrap();
+        cmd.push_str(&full_ws_name.to_string());
+        send_command(stream, &cmd);
+    } else {
+        move_container_to_workspace_absolute(stream, workspace_index);
+    }
+}
+
+fn move_container_to_workspace_absolute(stream: &UnixStream, workspace_index: usize) {
+    let output_index = (workspace_index / 10) as usize;
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+
+    // If the workspace already exists
+    match workspaces.iter().find(|w| w.num == workspace_index) {
+        Some(_) => {
+            let mut focus_cmd: String = "move container to workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+        None => {
+            let target_group = workspace_index / 10;
+            let target_screen_index = match workspaces.iter().find(|w| w.num / 10 == target_group) {
+                // If other workspaces on the same group exists
+                Some(other_workspace) => Some(
+                    outputs
+                        .iter()
+                        .enumerate()
+                        .find(|i| i.1.name == other_workspace.output)
+                        .unwrap()
+                        .0,
+                ),
+                None => {
+                    // Or if the targeted output is currently connected
+                    if output_index < outputs.len() {
+                        Some(output_index)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            match target_screen_index {
+                // If we have to send it to another screen
+                Some(target_screen_index) => {
+                    let target_output = &outputs[target_screen_index - 1];
+
+                    let current_output_name = get_current_output_name(stream);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+
+                    let focused_workspace_index = get_current_workspace(stream).num;
+
+                    let mut focus_cmd: String = "workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&current_output_name);
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "move container to workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "workspace ".to_string();
+                    focus_cmd.push_str(&focused_workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&current_output_name);
+                    send_command(stream, &focus_cmd);
+                }
+                None => {
+                    // Else, we send the container on the current output
+                    let mut focus_cmd: String = "move container to workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+                }
+            };
+        }
+    }
+}
+
+fn focus_to_workspace(stream: &UnixStream, workspace_index: usize) {
+    if workspace_index < 10 {
+        let mut cmd: String = "workspace number ".to_string();
+        let full_ws_name = format!("{}{}", get_current_output_index(stream), &workspace_index)
+            .parse::<i32>()
+            .unwrap();
+        cmd.push_str(&full_ws_name.to_string());
+        send_command(stream, &cmd);
+    } else {
+        focus_to_workspace_absolute(stream, workspace_index);
+    }
+}
+
+fn focus_to_workspace_absolute(stream: &UnixStream, workspace_index: usize) {
+    let output_index = (workspace_index / 10) as usize;
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+
+    // If the workspace already exists
+    match workspaces.iter().find(|w| w.num == workspace_index) {
+        Some(_) => {
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+        None => {
+            let target_group = workspace_index / 10;
+            let target_screen_index = match workspaces.iter().find(|w| w.num / 10 == target_group) {
+                // If other workspaces on the same group exists
+                Some(other_workspace) => Some(
+                    outputs
+                        .iter()
+                        .enumerate()
+                        .find(|i| i.1.name == other_workspace.output)
+                        .unwrap()
+                        .0,
+                ),
+                None => {
+                    // Or if the targeted output is currently connected
+                    if output_index < outputs.len() {
+                        Some(output_index)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            match target_screen_index {
+                // If we have to send it to another screen
+                Some(target_screen_index) => {
+                    let target_output = &outputs[target_screen_index - 1];
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+                }
+                None => {}
+            };
+            // Then we focus the workspace
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+    }
+}
+
+fn focus_to_workspace_virtual_output(stream: &UnixStream, workspace_index: usize) {
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let focused_output_index = current_workspace_index / 10;
+
+    let mut cmd: String = "workspace number ".to_string();
+    let full_ws_name = format!("{}{}", focused_output_index, &workspace_index)
         .parse::<i32>()
         .unwrap();
     cmd.push_str(&full_ws_name.to_string());
     send_command(stream, &cmd);
 }
 
-fn focus_to_workspace(stream: &UnixStream, workspace_index: usize) {
+fn focus_to_output(stream: &UnixStream, target_output_index: usize) {
-    let mut cmd: String = "workspace number ".to_string();
+    let outputs = get_outputs(stream);
-    let full_ws_name = format!("{}{}", get_current_output_index(stream), &workspace_index)
+    if target_output_index < outputs.len() {
-        .parse::<i32>()
+        let mut cmd: String = "focus output ".to_string();
-        .unwrap();
+        cmd.push_str(&outputs[target_output_index - 1].name);
-    cmd.push_str(&full_ws_name.to_string());
+        send_command(stream, &cmd);
-    send_command(stream, &cmd);
+    } else {
+        let current_workspace_index = get_current_workspace(stream).num;
+        let contextual_workspace_index =
+            current_workspace_index - (current_workspace_index / 10) * 10;
+        focus_to_workspace_virtual_output(stream, contextual_workspace_index);
+    }
 }
 
 fn focus_all_outputs_to_workspace(stream: &UnixStream, workspace_index: usize) {
@@ -258,15 +445,12 @@ fn move_container_to_prev_output(stream: &UnixStream) {
 
 fn move_container_to_next_or_prev_output(stream: &UnixStream, go_to_prev: bool) {
     let outputs = get_outputs(stream);
-    let focused_output_index = match outputs.iter().position(|x| x.focused) {
+    let focused_output_index = get_current_output_index(stream);
-        Some(i) => i,
-        None => panic!("WTF! No focused output???"),
-    };
 
     let target_output = if go_to_prev {
-        &outputs[(focused_output_index + outputs.len() - 1) % outputs.len()]
+        &outputs[(focused_output_index + outputs.len() - 1) % outputs.len() - 1]
     } else {
-        &outputs[(focused_output_index + 1) % outputs.len()]
+        &outputs[(focused_output_index + 1) % outputs.len() - 1]
     };
 
     let workspaces = get_workspaces(stream);
@@ -286,6 +470,42 @@ fn move_container_to_next_or_prev_output(stream: &UnixStream, go_to_prev: bool)
     send_command(stream, &cmd);
 }
 
+fn move_container_to_next_group(stream: &UnixStream) {
+    move_container_to_next_or_prev_group(stream, false);
+}
+
+fn move_container_to_prev_group(stream: &UnixStream) {
+    move_container_to_next_or_prev_group(stream, true);
+}
+
+fn move_container_to_next_or_prev_group(stream: &UnixStream, go_to_prev: bool) {
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let focused_group_index = current_workspace_index / 10;
+
+    let outputs = get_outputs(stream);
+    if focused_group_index < outputs.len() {
+        let target_output = if go_to_prev {
+            &outputs[(focused_group_index - 1) - 1]
+        } else {
+            &outputs[(focused_group_index + 1) - 1]
+        };
+
+        let mut cmd: String = "focus output ".to_string();
+        cmd.push_str(&target_output.name);
+        send_command(stream, &cmd);
+    } else {
+        let target_workspace = if go_to_prev {
+            current_workspace_index - 10
+        } else {
+            current_workspace_index + 10
+        };
+
+        let mut cmd: String = "workspace number ".to_string();
+        cmd.push_str(&target_workspace.to_string());
+        send_command(stream, &cmd);
+    };
+}
+
 fn init_workspaces(stream: &UnixStream, workspace_index: usize) {
     let outputs = get_outputs(stream);
 
@@ -313,7 +533,7 @@ fn rearrange_workspaces(stream: &UnixStream) {
         let output_index = workspace.num / 10;
         if output_index < outputs.len() {
             let mut move_cmd = move_cmd_prefix.clone();
-            move_cmd.push_str(&outputs[output_index].name);
+            move_cmd.push_str(&outputs[output_index - 1].name);
             send_command(stream, &move_cmd);
         }
     }
@@ -333,6 +553,9 @@ fn main() {
         Command::Focus(action) => {
             focus_to_workspace(&stream, action.index);
         }
+        Command::FocusOutput(action) => {
+            focus_to_output(&stream, action.index);
+        }
         Command::FocusAllOutputs(action) => {
             focus_all_outputs_to_workspace(&stream, action.index);
         }
@@ -342,6 +565,12 @@ fn main() {
         Command::PrevOutput => {
             move_container_to_prev_output(&stream);
         }
+        Command::NextGroup => {
+            move_container_to_next_group(&stream);
+        }
+        Command::PrevGroup => {
+            move_container_to_prev_group(&stream);
+        }
         Command::RearrangeWorkspaces => {
             rearrange_workspaces(&stream);
         }