Use cosmic-config for dynamic workspace settings

`WorkspaceAmount`, `WorkspaceMode`, and `WorkspaceLayout` can all be
changed dynamically now.

config.ron

@@ -81,8 +81,5 @@
         (modifiers: [], key: "XF86MonBrightnessUp"): Spawn("busctl --user call com.system76.CosmicSettingsDaemon /com/system76/CosmicSettingsDaemon com.system76.CosmicSettingsDaemon IncreaseDisplayBrightness"),
         (modifiers: [], key: "XF86MonBrightnessDown"): Spawn("busctl --user call com.system76.CosmicSettingsDaemon /com/system76/CosmicSettingsDaemon com.system76.CosmicSettingsDaemon DecreaseDisplayBrightness"),
     },
-    workspace_mode: OutputBound,
-    workspace_amount: Dynamic,
-    workspace_layout: Vertical,
     tiling_enabled: false,
 )

cosmic-comp-config/src/lib.rs

@@ -3,6 +3,7 @@
 use serde::{Deserialize, Serialize};
 
 pub mod input;
+pub mod workspace;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct XkbConfig {

cosmic-comp-config/src/workspace.rs

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use serde::{Deserialize, Serialize};
+
+fn default_workspace_layout() -> WorkspaceLayout {
+    WorkspaceLayout::Vertical
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkspaceConfig {
+    pub workspace_mode: WorkspaceMode,
+    pub workspace_amount: WorkspaceAmount,
+    #[serde(default = "default_workspace_layout")]
+    pub workspace_layout: WorkspaceLayout,
+}
+
+impl Default for WorkspaceConfig {
+    fn default() -> Self {
+        Self {
+            workspace_mode: WorkspaceMode::OutputBound,
+            workspace_amount: WorkspaceAmount::Dynamic,
+            workspace_layout: WorkspaceLayout::Vertical,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WorkspaceAmount {
+    Dynamic,
+    Static(u8),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WorkspaceMode {
+    OutputBound,
+    Global,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WorkspaceLayout {
+    Vertical,
+    Horizontal,
+}

src/backend/render/mod.rs

@@ -11,7 +11,6 @@ use std::{
 #[cfg(feature = "debug")]
 use crate::debug::{fps_ui, profiler_ui};
 use crate::{
-    config::WorkspaceLayout,
     shell::{
         focus::target::WindowGroup, grabs::SeatMoveGrabState, layout::tiling::ANIMATION_DURATION,
         CosmicMapped, CosmicMappedRenderElement, OverviewMode, Trigger, WorkspaceRenderElement,
@@ -32,6 +31,7 @@ use crate::{
     },
 };
 
+use cosmic_comp_config::workspace::WorkspaceLayout;
 use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_session_v1::FailureReason;
 use keyframe::{ease, functions::EaseInOutCubic};
 use smithay::{
@@ -557,7 +557,7 @@ where
 
     let offset = match previous.as_ref() {
         Some((previous, previous_idx, start)) => {
-            let layout = state.config.static_conf.workspace_layout;
+            let layout = state.config.workspace.workspace_layout;
 
             let workspace = state
                 .shell

src/config/key_bindings.rs

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::shell::{focus::FocusDirection, grabs::ResizeEdge, Direction, ResizeDirection};
+use cosmic_comp_config::workspace::WorkspaceLayout;
 use serde::Deserialize;
 use smithay::{
     backend::input::KeyState,
     input::keyboard::{xkb::keysym_get_name, ModifiersState},
 };
 use std::collections::HashMap;
 
-use super::{types::*, WorkspaceLayout};
+use super::types::*;
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
 pub enum KeyModifier {

src/config/mod.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::{
-    shell::{Shell, WorkspaceAmount},
+    shell::Shell,
     state::{BackendData, State},
     wayland::protocols::output_configuration::OutputConfigurationState,
 };
@@ -29,7 +29,11 @@ mod key_bindings;
 pub use key_bindings::{Action, KeyModifier, KeyModifiers, KeyPattern};
 mod types;
 pub use self::types::*;
-use cosmic_comp_config::{input::InputConfig, XkbConfig};
+use cosmic_comp_config::{
+    input::InputConfig,
+    workspace::{WorkspaceConfig, WorkspaceLayout},
+    XkbConfig,
+};
 
 #[derive(Debug)]
 pub struct Config {
@@ -40,30 +44,15 @@ pub struct Config {
     pub input_default: InputConfig,
     pub input_touchpad: InputConfig,
     pub input_devices: HashMap<String, InputConfig>,
+    pub workspace: WorkspaceConfig,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StaticConfig {
     pub key_bindings: HashMap<key_bindings::KeyPattern, key_bindings::Action>,
-    pub workspace_mode: WorkspaceMode,
-    pub workspace_amount: WorkspaceAmount,
-    #[serde(default = "default_workspace_layout")]
-    pub workspace_layout: WorkspaceLayout,
     pub tiling_enabled: bool,
 }
 
-#[derive(Debug, Deserialize, Clone, Copy, PartialEq, Eq)]
-pub enum WorkspaceMode {
-    OutputBound,
-    Global,
-}
-
-#[derive(Debug, Deserialize, Clone, Copy, PartialEq, Eq)]
-pub enum WorkspaceLayout {
-    Vertical,
-    Horizontal,
-}
-
 #[derive(Debug)]
 pub struct DynamicConfig {
     outputs: (Option<PathBuf>, OutputsConfig),
@@ -96,10 +85,6 @@ fn default_enabled() -> bool {
     true
 }
 
-fn default_workspace_layout() -> WorkspaceLayout {
-    WorkspaceLayout::Vertical
-}
-
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub struct OutputConfig {
     pub mode: ((i32, i32), Option<u32>),
@@ -155,18 +140,23 @@ impl Config {
             })
             .expect("Failed to add cosmic-config to the event loop");
         let xdg = xdg::BaseDirectories::new().ok();
+        let workspace = get_config::<WorkspaceConfig>(&config, "workspaces");
         Config {
-            static_conf: Self::load_static(xdg.as_ref()),
+            static_conf: Self::load_static(xdg.as_ref(), workspace.workspace_layout),
             dynamic_conf: Self::load_dynamic(xdg.as_ref()),
             xkb: get_config(&config, "xkb-config"),
             input_default: get_config(&config, "input-default"),
             input_touchpad: get_config(&config, "input-touchpad"),
             input_devices: get_config(&config, "input-devices"),
+            workspace,
             config,
         }
     }
 
-    fn load_static(xdg: Option<&xdg::BaseDirectories>) -> StaticConfig {
+    fn load_static(
+        xdg: Option<&xdg::BaseDirectories>,
+        workspace_layout: WorkspaceLayout,
+    ) -> StaticConfig {
         let mut locations = if let Some(base) = xdg {
             vec![
                 base.get_config_file("cosmic-comp.ron"),
@@ -192,20 +182,14 @@ impl Config {
                     ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap())
                         .expect("Malformed config file");
 
-                key_bindings::add_default_bindings(
-                    &mut config.key_bindings,
-                    config.workspace_layout,
-                );
+                key_bindings::add_default_bindings(&mut config.key_bindings, workspace_layout);
 
                 return config;
             }
         }
 
         StaticConfig {
             key_bindings: HashMap::new(),
-            workspace_mode: WorkspaceMode::Global,
-            workspace_amount: WorkspaceAmount::Dynamic,
-            workspace_layout: WorkspaceLayout::Vertical,
             tiling_enabled: false,
         }
     }
@@ -516,6 +500,11 @@ fn config_changed(config: cosmic_config::Config, keys: Vec<String>, state: &mut
                 state.common.config.input_devices = value;
                 update_input(state);
             }
+            "workspaces" => {
+                state.common.config.workspace =
+                    get_config::<WorkspaceConfig>(&config, "workspaces");
+                state.common.shell.update_config(&state.common.config);
+            }
             _ => {}
         }
     }

src/input/mod.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     backend::render::cursor::CursorState,
-    config::{xkb_config_to_wl, Action, Config, KeyPattern, WorkspaceLayout},
+    config::{xkb_config_to_wl, Action, Config, KeyPattern},
     shell::{
         focus::{target::PointerFocusTarget, FocusDirection},
         grabs::{ResizeEdge, SeatMoveGrabState},
@@ -18,6 +18,7 @@ use crate::{
     wayland::{handlers::screencopy::ScreencopySessions, protocols::screencopy::Session},
 };
 use calloop::{timer::Timer, RegistrationToken};
+use cosmic_comp_config::workspace::WorkspaceLayout;
 use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_session_v1::InputType;
 #[allow(deprecated)]
 use smithay::{
@@ -1518,7 +1519,7 @@ impl State {
 
                 match result {
                     FocusResult::None => {
-                        match (focus, self.common.config.static_conf.workspace_layout) {
+                        match (focus, self.common.config.workspace.workspace_layout) {
                             (FocusDirection::Left, WorkspaceLayout::Horizontal)
                             | (FocusDirection::Up, WorkspaceLayout::Vertical) => self
                                 .handle_action(
@@ -1574,7 +1575,7 @@ impl State {
 
                 match workspace.move_current_element(direction, seat) {
                     MoveResult::MoveFurther(_move_further) => {
-                        match (direction, self.common.config.static_conf.workspace_layout) {
+                        match (direction, self.common.config.workspace.workspace_layout) {
                             (Direction::Left, WorkspaceLayout::Horizontal)
                             | (Direction::Up, WorkspaceLayout::Vertical) => self.handle_action(
                                 Action::MoveToPreviousWorkspace,

src/shell/mod.rs

@@ -1,13 +1,13 @@
 use calloop::LoopHandle;
 use indexmap::IndexMap;
-use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
     sync::atomic::{AtomicBool, Ordering},
     time::{Duration, Instant},
 };
 use wayland_backend::server::ClientId;
 
+use cosmic_comp_config::workspace::{WorkspaceAmount, WorkspaceMode};
 use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
 use keyframe::{ease, functions::EaseInOutCubic};
 use smithay::{
@@ -35,7 +35,7 @@ use smithay::{
 };
 
 use crate::{
-    config::{Config, KeyModifiers, KeyPattern, WorkspaceMode},
+    config::{Config, KeyModifiers, KeyPattern},
     state::client_has_security_context,
     utils::prelude::*,
     wayland::protocols::{
@@ -189,12 +189,6 @@ pub struct WorkspaceSet {
     pub(crate) workspaces: Vec<Workspace>,
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum WorkspaceAmount {
-    Dynamic,
-    Static(u8),
-}
-
 fn create_workspace(
     state: &mut WorkspaceUpdateGuard<'_, State>,
     output: &Output,
@@ -466,8 +460,8 @@ impl Workspaces {
         Workspaces {
             sets: IndexMap::new(),
             backup_set: None,
-            amount: config.static_conf.workspace_amount,
-            mode: config.static_conf.workspace_mode,
+            amount: config.workspace.workspace_amount,
+            mode: config.workspace.workspace_mode,
             tiling_enabled: config.static_conf.tiling_enabled,
             theme,
         }
@@ -592,11 +586,16 @@ impl Workspaces {
         workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
         toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
     ) {
+        let old_mode = self.mode;
+
+        self.mode = config.workspace.workspace_mode;
+        self.amount = config.workspace.workspace_amount;
+
         if self.sets.len() <= 1 {
             return;
         }
 
-        match (self.mode, config.static_conf.workspace_mode) {
+        match (old_mode, self.mode) {
             (WorkspaceMode::Global, WorkspaceMode::OutputBound) => {
                 // We basically just unlink the existing spaces, so nothing needs to be updated
             }

src/wayland/protocols/workspace.rs

@@ -70,6 +70,7 @@ pub struct WorkspaceGroupHandle {
 pub struct WorkspaceGroupDataInner {
     outputs: Vec<Output>,
     capabilities: Vec<GroupCapabilities>,
+    workspace_count: usize,
 }
 pub type WorkspaceGroupData = Mutex<WorkspaceGroupDataInner>;
 
@@ -870,6 +871,11 @@ where
         changed = true;
     }
 
+    if handle_state.workspace_count != group.workspaces.len() {
+        changed = true;
+    }
+    handle_state.workspace_count = group.workspaces.len();
+
     for workspace in &mut group.workspaces {
         if send_workspace_to_client::<D>(dh, instance, workspace) {
             changed = true;