hlctl/src/hlwm/setting.rs

use std::str::FromStr;

use serde::{Deserialize, Serialize};

use crate::{gen_parse, hlwm::command::CommandParseError};
use strum::IntoEnumIterator;

use super::{
    color::Color,
    hlwmbool::ToggleBool,
    split::{self},
    StringParseError, ToCommandString,
};

#[derive(Debug, Clone, strum::Display, strum::EnumIter, PartialEq, strum::EnumDiscriminants)]
#[strum_discriminants(
    name(SettingName),
    derive(strum::Display, strum::EnumIter),
    strum(serialize_all = "snake_case")
)]
#[strum(serialize_all = "snake_case")]
pub enum Setting {
    /// If set, detect_monitors is automatically executed every time a monitor is connected, disconnected or resized.
    AutoDetectMonitors(ToggleBool),
    /// If set, EWMH panels are automatically detected and reserve space at the side of the monitors
    /// they are on (via pad attributes of each monitor).
    /// This setting is activated per default.
    AutoDetectPanels(ToggleBool),
    /// This setting controls the behaviour of focus and shift if no -e or -i argument is given.
    /// If set, then focus and shift changes the focused frame even if there are other clients
    /// in this frame in the specified direction.
    /// Else, a client within current frame is selected if it is in the specified direction.
    DefaultDirectionExternalOnly(ToggleBool),
    /// Name of the layout algorithm, which is used if a new frame is created (on a new tag or by a non-trivial split).
    DefaultFrameLayout(FrameLayout),
    /// String to append when window or tab titles are shortened to fit in the available space
    Ellipsis(String),
    /// If set, commands [HlwmCommand::Focus] and [HlwmCommand::Shift] cross monitor boundaries.
    /// If there is no client in the direction given to focus, then the monitor in the specified
    /// direction is focused.
    /// Similarly, if shift cannot move a window within a tag, the window is moved to the
    /// neighbour monitor in the desired direction.
    FocusCrossesMonitorBoundaries(ToggleBool),
    /// If set and a window is focused by mouse cursor, this window is focused
    /// (this feature is also known as sloppy focus).
    /// If unset, you need to click to change the window focus by mouse.
    ///
    /// If another window is hidden by the focus change
    /// (e.g. when having pseudotiled windows in the max layout)
    /// then an extra click is required to change the focus.
    FocusFollowsMouse(ToggleBool),
    /// If set, only pagers and taskbars are allowed to change the focus. If unset, all applications can request a
    /// focus change
    FocusStealingPrevention(ToggleBool),
    /// Focused frame opacity in percent. Requires a running compositing manager to take actual effect.
    FrameActiveOpacity(u8),
    /// The fill color of a focused frame
    FrameBgActiveColor(Color),
    /// The fill color of an unfocused frame
    /// It is only visible if non-focused frames are configured to be visible, see [ShowFrameDecoration].
    FrameBgNormalColor(Color),
    /// If set, the background of frames are transparent.
    /// That means a rectangle is cut out from the inner such that only the frame border
    /// and a stripe of width [Setting::FrameTransparentWidth] can be seen.
    /// Use [Setting::FrameActiveOpacity] and [Setting::FrameNormalOpacity] for real transparency.
    FrameBgTransparent(ToggleBool),
    /// The border color of a focused frame
    FrameBorderActiveColor(Color),
    /// The color of the inner border of a frame
    FrameBorderInnerColor(Color),
    /// The width of the inner border of a frame.
    /// Must be less than [Setting::FrameBorderWidth], since it does not add to the frame border width but is a
    /// part of it.
    FrameBorderInnerWidth(u32),
    /// The border color of an unfocused frame
    FrameBorderNormalColor(Color),
    /// Border width of a frame
    FrameBorderWidth(u32),
    /// The gap between frames in the tiling mode
    FrameGap(u32),
    /// Unfocused frame opacity in percent.
    /// Requires a running compositing manager to take actual effect
    FrameNormalOpacity(u8),
    /// The padding within a frame in the tiling mode
    /// i.e. the space between the border of a frame and the windows within it
    FramePadding(u32),
    /// Specifies the width of the remaining frame colored with [Setting::FrameBgActiveColor]
    /// if [Setting::FrameBgTransparent] is set
    FrameTransparentWidth(u32),
    /// This setting affects the size of the last client in a frame that is arranged by grid layout.
    /// If set, then the last client always fills the gap within this frame.
    /// If unset, then the last client has the same size as all other clients in this frame
    GaplessGrid(ToggleBool),
    /// If activated, windows are explicitly hidden when they are covered by another window in a frame with max layout.
    /// This only has a visible effect if a compositor is used.
    /// If activated, shadows do not stack up and transparent windows show the wallpaper behind them instead of
    /// the other clients in the max layout.
    HideCoveredWindows(ToggleBool),
    /// If greater than 0, then the clients on all monitors aren’t moved or resized anymore.
    /// If it is set to 0, then the arranging of monitors is enabled again, and all monitors are rearranged
    /// if their content has changed in the meantime.
    /// You should not change this setting manually due to concurrency issues;
    /// use the commands [HlwmCommand::Lock] and [HlwmCommand::Unlock] instead.
    MonitorsLocked(u8),
    /// Specifies the gap around a monitor.
    /// If the monitor is selected and the mouse position would be restored into this gap,
    /// it is set to the center of the monitor.
    /// This is useful, when the monitor was left via mouse movement, but is reselected by keyboard.
    /// If the gap is 0 (default), the mouse is never recentered
    MouseRecenterGap(u32),
    /// If greater than 0, it specifies the least distance between a centered pseudotile window
    /// and the border of the frame or tile it is assigned to.
    /// If this distance is lower than pseudotile_center_threshold, it is aligned to the top left
    ///  of the client’s tile.
    PseudotileCenterThreshold(u32),
    /// If set, a window is raised if it is clicked. The value of this setting is only noticed in floating mode
    RaiseOnClick(ToggleBool),
    /// If set, a window is raised if it is focused. The value of this setting is only used in floating mode
    RaiseOnFocus(ToggleBool),
    /// If set, a window is raised temporarily if it is focused on its tag.
    /// Temporarily in this case means that the window will return to its previous stacking position
    /// if another window is focused
    RaiseOnFocusTemporarily(ToggleBool),
    /// This controls, which frame decorations are shown (or none at all)
    ShowFrameDecorations(ShowFrameDecoration),
    /// See the docs for members of [SmartFrameSurroundings]
    SmartFrameSurroundings(SmartFrameSurroundings),
    /// If set, window borders and gaps will be removed and minimal when there’s no
    /// ambiguity regarding the focused window.
    /// This minimal window decoration can be configured by the `theme.minimal` object.
    SmartWindowSurroundings(ToggleBool),
    /// If a client is dragged in floating mode, then it snaps to neighbour clients
    /// if the distance between them is smaller than SnapDistance
    SnapDistance(u32),
    /// Specifies the remaining gap if a dragged client snaps to an edge in floating mode.
    /// If SnapGap is set to 0, no gap will remain
    SnapGap(u32),
    /// If set: If you want to view a tag, that already is viewed on another monitor,
    /// then the monitor contents will be swapped and you see the wanted tag on the focused monitor.
    /// If not set, the other monitor is focused if it shows the desired tag.
    SwapMonitorsToGetTag(ToggleBool),
    /// If activated, multiple windows in a frame with the max layout algorithm are drawn as tabs
    TabbedMax(ToggleBool),
    /// It contains the chars that are used to print a nice ascii tree.
    /// It must contain at least 8 characters. e.g. `X|:#+*-.` produces a tree like:
    /// ```
    /// X-.
    ///  #-. child 0
    ///  | #-* child 00
    ///  | +-* child 01
    ///  +-. child 1
    ///  : #-* child 10
    ///  : +-* child 11
    /// ```
    /// Useful values for tree_style are: `╾│ ├└╼─┐` or `-| |'--.` or `╾│ ├╰╼─╮.`
    TreeStyle(String),
    /// If set, a client's window content is resized immediately during resizing it with the mouse.
    /// If unset, the client's content is resized after the mouse button is released.
    UpdateDraggedClients(ToggleBool),
    /// If set, verbose output is logged to herbstluftwm’s stderr.
    /// The default value is controlled by the `--verbose` command line flag
    Verbose(ToggleBool),
    /// Border color of a focused window
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.active.color`
    WindowBorderActiveColor(Color),
    /// Color of the inner border of a window.
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.inner_color`
    WindowBorderInnerColor(Color),
    /// The width of the inner border of a window.
    /// Must be less than window_border_width, since it does not add to the window border width but is a part of it.
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.inner_width`
    WindowBorderInnerWidth(u32),
    /// Border color of an unfocused window
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.normal.color`
    WindowBorderNormalColor(Color),
    /// Border color of an unfocused but urgent window.
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.urgent.color`
    WindowBorderUrgentColor(Color),
    /// Border width of a window
    /// **Warning:**
    /// 	This only exists for compatibility reasons; it is only an alias for the attribute `theme.border_width`
    WindowBorderWidth(u32),
    /// The gap between windows within one frame in the tiling mode.
    WindowGap(u32),
    /// It controls the value of the `_NET_WM_NAME` property on the root window,
    /// which specifies the name of the running window manager.
    /// The value of this setting is not updated if the actual `_NET_WM_NAME` property
    /// on the root window is changed externally. Example usage:
    ///
    /// ```
    /// cycle_value wmname herbstluftwm LG3D
    /// ```
    Wmname(String),
}

impl Default for SettingName {
    fn default() -> Self {
        SettingName::AutoDetectMonitors
    }
}

impl FromStr for SettingName {
    type Err = StringParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::iter()
            .find(|i| i.to_string() == s)
            .ok_or(StringParseError::UnknownValue)
    }
}

impl Serialize for Setting {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_command_string().replace("\t", " = "))
    }
}

impl<'de> Deserialize<'de> for Setting {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let str_val: String = Deserialize::deserialize(deserializer)?;
        let ((command, arg), _) = split::on_first_match(&str_val, &['='])
            .ok_or(CommandParseError::InvalidArgumentCount(0, "setting".into()))
            .map_err(|err| {
                serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &err)
            })?;
        Ok(
            Self::from_raw_parts(&command.trim(), &arg.trim()).map_err(|err| {
                serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &err)
            })?,
        )
    }
}

impl FromStr for Setting {
    type Err = CommandParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let ((command, arg), _) = split::on_first_match(s, &['\t', ' '])
            .ok_or(CommandParseError::InvalidArgumentCount(0, "setting".into()))?;

        Self::from_raw_parts(&command.trim(), &arg.trim())
    }
}

impl Setting {
    pub fn from_raw_parts(command: &str, arg: &str) -> Result<Self, CommandParseError> {
        let command = Self::iter()
            .find(|cmd| cmd.to_string() == command)
            .ok_or(CommandParseError::UnknownCommand(command.to_string()))?;

        let args = [arg.to_string()];
        gen_parse!(command, args);

        match command {
            Setting::Verbose(_) => parse!(FromStr => Verbose),
            Setting::TabbedMax(_) => parse!(FromStr => TabbedMax),
            Setting::GaplessGrid(_) => parse!(FromStr => GaplessGrid),
            Setting::RaiseOnClick(_) => parse!(FromStr => RaiseOnClick),
            Setting::RaiseOnFocus(_) => parse!(FromStr => RaiseOnFocus),
            Setting::AutoDetectPanels(_) => parse!(FromStr => AutoDetectPanels),
            Setting::FocusFollowsMouse(_) => parse!(FromStr => FocusFollowsMouse),
            Setting::HideCoveredWindows(_) => parse!(FromStr => HideCoveredWindows),
            Setting::AutoDetectMonitors(_) => parse!(FromStr => AutoDetectMonitors),
            Setting::FrameBgTransparent(_) => parse!(FromStr => FrameBgTransparent),
            Setting::SwapMonitorsToGetTag(_) => parse!(FromStr => SwapMonitorsToGetTag),
            Setting::UpdateDraggedClients(_) => parse!(FromStr => UpdateDraggedClients),
            Setting::FocusStealingPrevention(_) => parse!(FromStr => FocusStealingPrevention),
            Setting::RaiseOnFocusTemporarily(_) => parse!(FromStr => RaiseOnFocusTemporarily),
            Setting::SmartWindowSurroundings(_) => parse!(FromStr => SmartWindowSurroundings),
            Setting::DefaultDirectionExternalOnly(_) => {
                parse!(FromStr => DefaultDirectionExternalOnly)
            }
            Setting::FocusCrossesMonitorBoundaries(_) => {
                parse!(FromStr => FocusCrossesMonitorBoundaries)
            }

            Setting::FrameBgActiveColor(_) => parse!(FromStr => FrameBgActiveColor),
            Setting::FrameBgNormalColor(_) => parse!(FromStr => FrameBgNormalColor),
            Setting::DefaultFrameLayout(_) => parse!(FromStr => DefaultFrameLayout),
            Setting::ShowFrameDecorations(_) => parse!(FromStr => ShowFrameDecorations),
            Setting::FrameBorderInnerColor(_) => parse!(FromStr => FrameBorderInnerColor),
            Setting::FrameBorderActiveColor(_) => parse!(FromStr => FrameBorderActiveColor),
            Setting::FrameBorderNormalColor(_) => parse!(FromStr => FrameBorderNormalColor),
            Setting::SmartFrameSurroundings(_) => parse!(FromStr => SmartFrameSurroundings),
            Setting::WindowBorderInnerColor(_) => parse!(FromStr => WindowBorderInnerColor),
            Setting::WindowBorderActiveColor(_) => parse!(FromStr => WindowBorderActiveColor),
            Setting::WindowBorderNormalColor(_) => parse!(FromStr => WindowBorderNormalColor),
            Setting::WindowBorderUrgentColor(_) => parse!(FromStr => WindowBorderUrgentColor),

            Setting::SnapGap(_) => parse!(FromStr => SnapGap),
            Setting::FrameGap(_) => parse!(FromStr => FrameGap),
            Setting::WindowGap(_) => parse!(FromStr => WindowGap),
            Setting::SnapDistance(_) => parse!(FromStr => SnapDistance),
            Setting::FramePadding(_) => parse!(FromStr => FramePadding),
            Setting::MonitorsLocked(_) => parse!(FromStr => MonitorsLocked),
            Setting::MouseRecenterGap(_) => parse!(FromStr => MouseRecenterGap),
            Setting::FrameBorderWidth(_) => parse!(FromStr => FrameBorderWidth),
            Setting::WindowBorderWidth(_) => parse!(FromStr => WindowBorderWidth),
            Setting::FrameActiveOpacity(_) => parse!(FromStr => FrameActiveOpacity),
            Setting::FrameNormalOpacity(_) => parse!(FromStr => FrameNormalOpacity),
            Setting::FrameTransparentWidth(_) => parse!(FromStr => FrameTransparentWidth),
            Setting::FrameBorderInnerWidth(_) => parse!(FromStr => FrameBorderInnerWidth),
            Setting::WindowBorderInnerWidth(_) => parse!(FromStr => WindowBorderInnerWidth),
            Setting::PseudotileCenterThreshold(_) => parse!(FromStr => PseudotileCenterThreshold),

            Setting::Wmname(_) => parse!(String => Wmname),
            Setting::Ellipsis(_) => parse!(String => Ellipsis),
            Setting::TreeStyle(_) => parse!(String => TreeStyle),
        }
    }
}

impl Default for Setting {
    fn default() -> Self {
        Self::AutoDetectMonitors(ToggleBool::Bool(true))
    }
}

impl ToCommandString for Setting {
    fn to_command_string(&self) -> String {
        match self {
            Setting::AutoDetectMonitors(value)
            | Setting::AutoDetectPanels(value)
            | Setting::DefaultDirectionExternalOnly(value)
            | Setting::FocusCrossesMonitorBoundaries(value)
            | Setting::FocusFollowsMouse(value)
            | Setting::FocusStealingPrevention(value)
            | Setting::FrameBgTransparent(value)
            | Setting::GaplessGrid(value)
            | Setting::HideCoveredWindows(value)
            | Setting::RaiseOnClick(value)
            | Setting::RaiseOnFocus(value)
            | Setting::RaiseOnFocusTemporarily(value)
            | Setting::SmartWindowSurroundings(value)
            | Setting::TabbedMax(value)
            | Setting::UpdateDraggedClients(value)
            | Setting::Verbose(value)
            | Setting::SwapMonitorsToGetTag(value) => vec![self.to_string(), value.to_string()],

            Setting::TreeStyle(value) | Setting::Wmname(value) | Setting::Ellipsis(value) => {
                vec![self.to_string(), value.to_string()]
            }

            Setting::FrameActiveOpacity(value)
            | Setting::FrameNormalOpacity(value)
            | Setting::MonitorsLocked(value) => vec![self.to_string(), value.to_string()],

            Setting::FrameBorderInnerWidth(value)
            | Setting::FrameBorderWidth(value)
            | Setting::FrameGap(value)
            | Setting::FramePadding(value)
            | Setting::FrameTransparentWidth(value)
            | Setting::MouseRecenterGap(value)
            | Setting::PseudotileCenterThreshold(value)
            | Setting::SnapDistance(value)
            | Setting::SnapGap(value)
            | Setting::WindowBorderInnerWidth(value)
            | Setting::WindowBorderWidth(value)
            | Setting::WindowGap(value) => vec![self.to_string(), value.to_string()],

            Setting::FrameBgActiveColor(value)
            | Setting::FrameBgNormalColor(value)
            | Setting::FrameBorderActiveColor(value)
            | Setting::FrameBorderInnerColor(value)
            | Setting::FrameBorderNormalColor(value)
            | Setting::WindowBorderActiveColor(value)
            | Setting::WindowBorderInnerColor(value)
            | Setting::WindowBorderNormalColor(value)
            | Setting::WindowBorderUrgentColor(value) => vec![self.to_string(), value.to_string()],

            Setting::DefaultFrameLayout(value) => vec![self.to_string(), value.to_string()],
            Setting::ShowFrameDecorations(value) => vec![self.to_string(), value.to_string()],
            Setting::SmartFrameSurroundings(value) => vec![self.to_string(), value.to_string()],
        }
        .join("\t")
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, strum::Display, strum::EnumString, PartialEq)]
#[strum(serialize_all = "snake_case")]
pub enum ShowFrameDecoration {
    /// Show no frame decorations at all
    None,
    /// Show decorations of frames that have client windows,
    Nonempty,
    /// Show decorations on the tags with at least two frames,
    IfMultiple,
    /// Show decorations of frames that have no client windows,
    IfEmpty,
    /// Show the decoration of focused and nonempty frames,
    Focused,
    /// Show decorations of focused and non-empty frames on tags with at least two frames.
    FocusedIfMultiple,
    /// Show all frame decorations.
    All,
}

impl Default for ShowFrameDecoration {
    fn default() -> Self {
        Self::FocusedIfMultiple
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, strum::Display, strum::EnumString, PartialEq)]
#[strum(serialize_all = "snake_case")]
pub enum SmartFrameSurroundings {
    /// Frame borders and gaps will be removed when there is no ambiguity regarding the focused frame
    HideAll,
    /// Only frame gaps will be removed when there is no ambiguity regarding the focused frame
    HideGaps,
    /// Always show frame borders and gaps
    Off,
}

impl Default for SmartFrameSurroundings {
    fn default() -> Self {
        Self::Off
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, strum::Display, strum::EnumString, PartialEq)]
#[strum(serialize_all = "snake_case")]
pub enum FrameLayout {
    /// clients are placed below each other
    Vertical,
    /// clients are placed next to each other
    Horizontal,
    /// all clients are maximized in this frame   
    Max,
    /// clients are arranged in an almost quadratic grid
    Grid,
}

impl Default for FrameLayout {
    fn default() -> Self {
        Self::Vertical
    }
}

#[cfg(test)]
mod test {
    use serde::{Deserialize, Serialize};

    use crate::hlwm::{setting::SettingName, ToggleBool};

    use super::Setting;

    #[derive(Debug, Serialize, Deserialize)]
    pub struct SettingWrapper {
        setting: Setting,
    }

    #[test]
    fn setting_serialize_deserialize() {
        let setting = SettingWrapper {
            setting: Setting::AutoDetectMonitors(ToggleBool::Toggle),
        };
        let serialized = toml::to_string_pretty(&setting).expect("serializing");
        let deserialized: SettingWrapper = toml::from_str(&serialized).expect("deserializing");
        assert_eq!(setting.setting, deserialized.setting);
    }

    #[test]
    fn setting_name() {
        assert_eq!(
            "auto_detect_monitors",
            SettingName::AutoDetectMonitors.to_string()
        )
    }
}