feat(wm): add tiling and floating ws layers

This commit introduces an implementation of workspace layers to
komorebi.

Workspace layers change the kinds of windows that certain commands
operate on. This implementation features two variants,
WorkspaceLayer::Tiling and WorkspaceLayer::Floating.

The default behaviour until now has been WorkspaceLayer::Tiling.

When the user sets WorkspaceLayer::Floating, either through the
'toggle-workspace-layer' command or the new bar widget, the 'move',
'focus', 'cycle-focus' and 'resize-axis' commands will operate on
floating windows, if the currently focused window is a floating window.

As I don't have 'cycle-focus' bound to anything, 'focus up' and 'focus
down' double as incrementing and decrementing cycle focus commands,
iterating focus through the floating windows assigned to a workspace.

Floating windows in komorebi belong to specific workspaces, therefore
commands such as 'move' and 'resize-axis' will restrict movement and
resizing to the bounds of their workspace's work area (or more
accurately, the work area of the monitor that the workspace belongs to,
as floating windows are never constrained by workspace-specific work
area restrictions).

docs/cli/toggle-workspace-layer.md

@@ -0,0 +1,12 @@
+# toggle-workspace-layer
+
+```
+Toggle between the Tiling and Floating layers on the focused workspace
+
+Usage: komorebic.exe toggle-workspace-layer
+
+Options:
+  -h, --help
+          Print help
+
+```

komorebi-bar/src/bar.rs

@@ -365,16 +365,10 @@ impl Komobar {
                         &SocketMessage::MonitorWorkAreaOffset(monitor_index, new_rect),
                     ) {
                         tracing::error!(
-                            "error applying work area offset to monitor '{}': {}",
-                            monitor_index,
-                            error,
+                            "error applying work area offset to monitor '{monitor_index}': {error}"
                         );
                     } else {
-                        tracing::info!(
-                            "work area offset applied to monitor: {}\n, {:#?}",
-                            monitor_index,
-                            new_rect
-                        );
+                        tracing::info!("work area offset applied to monitor: {monitor_index}",);
                     }
                 }
             }
@@ -631,10 +625,10 @@ impl Komobar {
             let window = komorebi_client::Window::from(hwnd);
             match window.set_position(&self.size_rect, false) {
                 Ok(_) => {
-                    tracing::info!("updated bar position: {:#?}", &self.size_rect);
+                    tracing::info!("updated bar position");
                 }
                 Err(error) => {
-                    tracing::error!("{}", error.to_string())
+                    tracing::error!("{error}")
                 }
             }
         }

komorebi-bar/src/komorebi.rs

@@ -33,6 +33,7 @@ use komorebi_client::Rect;
 use komorebi_client::SocketMessage;
 use komorebi_client::Window;
 use komorebi_client::Workspace;
+use komorebi_client::WorkspaceLayer;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
@@ -49,6 +50,8 @@ pub struct KomorebiConfig {
     pub workspaces: Option<KomorebiWorkspacesConfig>,
     /// Configure the Layout widget
     pub layout: Option<KomorebiLayoutConfig>,
+    /// Configure the Workspace Layer widget
+    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     /// Configure the Focused Window widget
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
     /// Configure the Configuration Switcher widget
@@ -75,6 +78,12 @@ pub struct KomorebiLayoutConfig {
     pub display: Option<DisplayFormat>,
 }
 
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct KomorebiWorkspaceLayerConfig {
+    /// Enable the Komorebi Workspace Layer widget
+    pub enable: bool,
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiFocusedWindowConfig {
     /// Enable the Komorebi Focused Window widget
@@ -127,6 +136,7 @@ impl From<&KomorebiConfig> for Komorebi {
             workspaces: value.workspaces,
             layout: value.layout.clone(),
             focused_window: value.focused_window,
+            workspace_layer: value.workspace_layer,
             configuration_switcher,
         }
     }
@@ -138,6 +148,7 @@ pub struct Komorebi {
     pub workspaces: Option<KomorebiWorkspacesConfig>,
     pub layout: Option<KomorebiLayoutConfig>,
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
+    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
@@ -154,7 +165,7 @@ impl BarWidget for Komorebi {
                     let format = workspaces.display.unwrap_or(DisplayFormat::Text);
 
                     config.apply_on_widget(false, ui, |ui| {
-                        for (i, (ws, container_information)) in
+                        for (i, (ws, container_information, _)) in
                             komorebi_notification_state.workspaces.iter().enumerate()
                         {
                             if SelectableFrame::new(
@@ -281,6 +292,42 @@ impl BarWidget for Komorebi {
             }
         }
 
+        if let Some(layer_config) = &self.workspace_layer {
+            if layer_config.enable {
+                let layer = komorebi_notification_state
+                    .workspaces
+                    .iter()
+                    .find(|o| komorebi_notification_state.selected_workspace.eq(&o.0))
+                    .map(|(_, _, layer)| layer);
+
+                if let Some(layer) = layer {
+                    let name = layer.to_string();
+                    config.apply_on_widget(false, ui, |ui| {
+                        if SelectableFrame::new(false)
+                            .show(ui, |ui| ui.add(Label::new(name).selectable(false)))
+                            .clicked()
+                            && komorebi_client::send_batch([
+                                SocketMessage::MouseFollowsFocus(false),
+                                SocketMessage::ToggleWorkspaceLayer,
+                                SocketMessage::MouseFollowsFocus(
+                                    komorebi_notification_state.mouse_follows_focus,
+                                ),
+                            ])
+                            .is_err()
+                        {
+                            tracing::error!(
+                                "could not send the following batch of messages to komorebi:\n\
+                                            MouseFollowsFocus(false),
+                                            ToggleWorkspaceLayer,
+                                            MouseFollowsFocus({})",
+                                komorebi_notification_state.mouse_follows_focus,
+                            );
+                        }
+                    });
+                }
+            }
+        }
+
         if let Some(layout_config) = &self.layout {
             if layout_config.enable {
                 let workspace_idx: Option<usize> = komorebi_notification_state
@@ -476,7 +523,11 @@ fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {
 
 #[derive(Clone, Debug)]
 pub struct KomorebiNotificationState {
-    pub workspaces: Vec<(String, KomorebiNotificationStateContainerInformation)>,
+    pub workspaces: Vec<(
+        String,
+        KomorebiNotificationStateContainerInformation,
+        WorkspaceLayer,
+    )>,
     pub selected_workspace: String,
     pub focused_container_information: KomorebiNotificationStateContainerInformation,
     pub layout: KomorebiLayout,
@@ -592,6 +643,7 @@ impl KomorebiNotificationState {
                 workspaces.push((
                     ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)),
                     ws.into(),
+                    ws.layer().to_owned(),
                 ));
             }
         }

komorebi-client/src/lib.rs

@@ -48,6 +48,7 @@ pub use komorebi::ring::Ring;
 pub use komorebi::window::Window;
 pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
+pub use komorebi::workspace::WorkspaceLayer;
 pub use komorebi::AnimationsConfig;
 pub use komorebi::AspectRatio;
 pub use komorebi::BorderColours;

komorebi/src/core/mod.rs

@@ -149,6 +149,7 @@ pub enum SocketMessage {
     NamedWorkspaceLayoutCustomRule(String, usize, PathBuf),
     ClearWorkspaceLayoutRules(usize, usize),
     ClearNamedWorkspaceLayoutRules(String),
+    ToggleWorkspaceLayer,
     // Configuration
     ReloadConfiguration,
     ReplaceConfiguration(PathBuf),

komorebi/src/process_command.rs

@@ -66,6 +66,7 @@ use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
+use crate::workspace::WorkspaceLayer;
 use crate::workspace::WorkspaceWindowLocation;
 use crate::GlobalState;
 use crate::Notification;
@@ -291,13 +292,37 @@ impl WindowManager {
                 }
             }
             SocketMessage::FocusWindow(direction) => {
-                self.focus_container_in_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.focus_container_in_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.focus_floating_window_in_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::MoveWindow(direction) => {
-                self.move_container_in_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.move_container_in_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.move_floating_window_in_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::CycleFocusWindow(direction) => {
-                self.focus_container_in_cycle_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.focus_container_in_cycle_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.focus_floating_window_in_cycle_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::CycleMoveWindow(direction) => {
                 self.move_container_in_cycle_direction(direction)?;
@@ -1020,6 +1045,29 @@ impl WindowManager {
                     self.focus_workspace(workspace_idx)?;
                 }
             }
+            SocketMessage::ToggleWorkspaceLayer => {
+                let mouse_follows_focus = self.mouse_follows_focus;
+                let workspace = self.focused_workspace_mut()?;
+
+                match workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        workspace.set_layer(WorkspaceLayer::Floating);
+
+                        if let Some(first) = workspace.floating_windows().first() {
+                            first.focus(mouse_follows_focus)?;
+                        }
+                    }
+                    WorkspaceLayer::Floating => {
+                        workspace.set_layer(WorkspaceLayer::Tiling);
+
+                        if let Some(container) = workspace.focused_container() {
+                            if let Some(window) = container.focused_window() {
+                                window.focus(mouse_follows_focus)?;
+                            }
+                        }
+                    }
+                };
+            }
             SocketMessage::Stop => {
                 self.stop(false)?;
             }

komorebi/src/process_event.rs

@@ -26,6 +26,7 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
+use crate::workspace::WorkspaceLayer;
 use crate::workspace_reconciliator;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
@@ -280,10 +281,13 @@ impl WindowManager {
                         } else {
                             workspace.focus_container_by_window(window.hwnd)?;
                         }
+
+                        workspace.set_layer(WorkspaceLayer::Tiling);
                     }
                     Some(idx) => {
                         if let Some(window) = workspace.floating_windows().get(idx) {
                             window.focus(false)?;
+                            workspace.set_layer(WorkspaceLayer::Floating);
                         }
                     }
                 }
@@ -393,11 +397,13 @@ impl WindowManager {
 
                             if behaviour.float_override {
                                 workspace.floating_windows_mut().push(window);
+                                workspace.set_layer(WorkspaceLayer::Floating);
                                 self.update_focused_workspace(false, false)?;
                             } else {
                                 match behaviour.current_behaviour {
                                     WindowContainerBehaviour::Create => {
                                         workspace.new_container_for_window(window);
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
                                         self.update_focused_workspace(false, false)?;
                                     }
                                     WindowContainerBehaviour::Append => {
@@ -407,6 +413,7 @@ impl WindowManager {
                                                 anyhow!("there is no focused container")
                                             })?
                                             .add_window(window);
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
                                         self.update_focused_workspace(true, false)?;
                                         stackbar_manager::send_notification();
                                     }