feat(wm): add command to create new workspace

This commit adds a new command, 'komorebic.exe new-workspace', which
will append a new, empty workspace, to the list of workspaces on the
currently focused monitor, and then switch focus to it.

Also took the opportunity to clean up some unnecessary unwraps in
komorebic/src/main.rs.

resolve #4

komorebi-core/src/lib.rs

@@ -39,6 +39,7 @@ pub enum SocketMessage {
  FlipLayout(LayoutFlip),
  // Monitor and Workspace Commands
  EnsureWorkspaces(usize, usize),
+ NewWorkspace,
  Stop,
  TogglePause,
  Retile,

komorebi/src/monitor.rs

@@ -128,6 +128,10 @@ impl Monitor {
  Ok(())
  }
 
+ pub fn new_workspace_idx(&self) -> usize {
+ self.workspaces().len()
+ }
+
  pub fn update_focused_workspace(&mut self) -> Result<()> {
  let work_area = *self.work_area_size();
 

komorebi/src/process_command.rs

@@ -139,6 +139,9 @@ impl WindowManager {
  SocketMessage::EnsureWorkspaces(monitor_idx, workspace_count) => {
  self.ensure_workspaces_for_monitor(monitor_idx, workspace_count)?;
  }
+ SocketMessage::NewWorkspace => {
+ self.new_workspace()?;
+ }
  SocketMessage::WorkspaceName(monitor_idx, workspace_idx, name) => {
  self.set_workspace_name(monitor_idx, workspace_idx, name)?;
  }

komorebi/src/window_manager.rs

@@ -682,6 +682,20 @@ impl WindowManager {
  self.update_focused_workspace(true)
  }
 
+ #[tracing::instrument(skip(self))]
+ pub fn new_workspace(&mut self) -> Result<()> {
+ tracing::info!("adding new workspace");
+
+ let monitor = self
+ .focused_monitor_mut()
+ .context("there is no workspace")?;
+
+ monitor.focus_workspace(monitor.new_workspace_idx())?;
+ monitor.load_focused_workspace()?;
+
+ self.update_focused_workspace(true)
+ }
+
  pub fn focused_container(&self) -> Result<&Container> {
  self.focused_workspace()?
  .focused_container()

komorebic/src/main.rs

@@ -40,6 +40,7 @@ enum SubCommand {
  MoveToWorkspace(Target),
  FocusMonitor(Target),
  FocusWorkspace(Target),
+ NewWorkspace,
  Promote,
  EnsureWorkspaces(WorkspaceCountForMonitor),
  Retile,
@@ -132,81 +133,71 @@ fn main() -> Result<()> {
 
  match opts.subcmd {
  SubCommand::Focus(direction) => {
- let bytes = SocketMessage::FocusWindow(direction).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FocusWindow(direction).as_bytes()?)?;
  }
  SubCommand::Promote => {
- let bytes = SocketMessage::Promote.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::Promote.as_bytes()?)?;
  }
  SubCommand::TogglePause => {
- let bytes = SocketMessage::TogglePause.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::TogglePause.as_bytes()?)?;
  }
  SubCommand::Retile => {
- let bytes = SocketMessage::Retile.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::Retile.as_bytes()?)?;
  }
  SubCommand::Move(direction) => {
- let bytes = SocketMessage::MoveWindow(direction).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::MoveWindow(direction).as_bytes()?)?;
  }
  SubCommand::MoveToMonitor(display) => {
- let bytes = SocketMessage::MoveContainerToMonitorNumber(display.number)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::MoveContainerToMonitorNumber(display.number).as_bytes()?,
+ )?;
  }
  SubCommand::MoveToWorkspace(workspace) => {
- let bytes = SocketMessage::MoveContainerToWorkspaceNumber(workspace.number)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::MoveContainerToWorkspaceNumber(workspace.number).as_bytes()?,
+ )?;
  }
  SubCommand::ContainerPadding(gap) => {
- let bytes = SocketMessage::ContainerPadding(gap.monitor, gap.workspace, gap.size)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::ContainerPadding(gap.monitor, gap.workspace, gap.size)
+  .as_bytes()?,
+ )?;
  }
  SubCommand::WorkspacePadding(gap) => {
- let bytes = SocketMessage::WorkspacePadding(gap.monitor, gap.workspace, gap.size)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::WorkspacePadding(gap.monitor, gap.workspace, gap.size)
+  .as_bytes()?,
+ )?;
  }
  SubCommand::AdjustWorkspacePadding(sizing_adjustment) => {
- let bytes = SocketMessage::AdjustWorkspacePadding(
- sizing_adjustment.sizing,
- sizing_adjustment.adjustment,
- )
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::AdjustWorkspacePadding(
+  sizing_adjustment.sizing,
+  sizing_adjustment.adjustment,
+  )
+  .as_bytes()?,
+ )?;
  }
  SubCommand::AdjustContainerPadding(sizing_adjustment) => {
- let bytes = SocketMessage::AdjustContainerPadding(
- sizing_adjustment.sizing,
- sizing_adjustment.adjustment,
- )
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::AdjustContainerPadding(
+  sizing_adjustment.sizing,
+  sizing_adjustment.adjustment,
+  )
+  .as_bytes()?,
+ )?;
  }
  SubCommand::ToggleFloat => {
- let bytes = SocketMessage::ToggleFloat.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::ToggleFloat.as_bytes()?)?;
  }
  SubCommand::ToggleMonocle => {
- let bytes = SocketMessage::ToggleMonocle.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::ToggleMonocle.as_bytes()?)?;
  }
  SubCommand::WorkspaceLayout(layout) => {
- let bytes =
- SocketMessage::WorkspaceLayout(layout.monitor, layout.workspace, layout.layout)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::WorkspaceLayout(layout.monitor, layout.workspace, layout.layout)
+ .as_bytes()?,
+ )?;
  }
  SubCommand::Start => {
  let script = r#"Start-Process komorebi -WindowStyle hidden"#;
@@ -220,61 +211,49 @@ fn main() -> Result<()> {
  }
  }
  SubCommand::Stop => {
- let bytes = SocketMessage::Stop.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::Stop.as_bytes()?)?;
  }
  SubCommand::FloatClass(target) => {
- let bytes = SocketMessage::FloatClass(target.id).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FloatClass(target.id).as_bytes()?)?;
  }
  SubCommand::FloatExe(target) => {
- let bytes = SocketMessage::FloatExe(target.id).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FloatExe(target.id).as_bytes()?)?;
  }
  SubCommand::FloatTitle(target) => {
- let bytes = SocketMessage::FloatTitle(target.id).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FloatTitle(target.id).as_bytes()?)?;
  }
  SubCommand::Stack(direction) => {
- let bytes = SocketMessage::StackWindow(direction).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::StackWindow(direction).as_bytes()?)?;
  }
  SubCommand::Unstack => {
- let bytes = SocketMessage::UnstackWindow.as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::UnstackWindow.as_bytes()?)?;
  }
  SubCommand::CycleStack(direction) => {
- let bytes = SocketMessage::CycleStack(direction).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::CycleStack(direction).as_bytes()?)?;
  }
  SubCommand::FlipLayout(flip) => {
- let bytes = SocketMessage::FlipLayout(flip).as_bytes()?;
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FlipLayout(flip).as_bytes()?)?;
  }
  SubCommand::FocusMonitor(target) => {
- let bytes = SocketMessage::FocusMonitorNumber(target.number)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FocusMonitorNumber(target.number).as_bytes()?)?;
  }
  SubCommand::FocusWorkspace(target) => {
- let bytes = SocketMessage::FocusWorkspaceNumber(target.number)
-  .as_bytes()
-  .unwrap();
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FocusWorkspaceNumber(target.number).as_bytes()?)?;
+ }
+ SubCommand::NewWorkspace => {
+ send_message(&*SocketMessage::NewWorkspace.as_bytes()?)?;
  }
  SubCommand::WorkspaceName(name) => {
- let bytes = SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
+  .as_bytes()?,
+ )?;
  }
  SubCommand::EnsureWorkspaces(workspaces) => {
- let bytes =
- SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(
+ &*SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
+ .as_bytes()?,
+ )?;
  }
  SubCommand::State => {
  let home = dirs::home_dir().context("there is no home directory")?;
@@ -293,8 +272,7 @@ fn main() -> Result<()> {
  },
  };
 
- let bytes = SocketMessage::State.as_bytes().unwrap();
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::State.as_bytes()?)?;
 
  let listener = UnixListener::bind(&socket)?;
  match listener.accept() {
@@ -324,19 +302,15 @@ fn main() -> Result<()> {
  }
  }
  SubCommand::Resize(resize) => {
- let bytes = SocketMessage::ResizeWindow(resize.edge, resize.sizing)
- .as_bytes()
- .unwrap();
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::ResizeWindow(resize.edge, resize.sizing).as_bytes()?)?;
  }
  SubCommand::FocusFollowsMouse(enable) => {
  let enable = match enable {
  BooleanState::Enable => true,
  BooleanState::Disable => false,
  };
 
- let bytes = SocketMessage::FocusFollowsMouse(enable).as_bytes().unwrap();
- send_message(&*bytes)?;
+ send_message(&*SocketMessage::FocusFollowsMouse(enable).as_bytes()?)?;
  }
  }