monolith

//! The TOML config. Parsing and validation only, the compositor applies it.

use monolith_ipc::Command;

use regex::Regex;

use serde::Deserialize;

use serde::de::DeserializeOwned;

use std::fmt;

use std::path::{Path, PathBuf};

pub const DEFAULT: &str = include_str!("../default.toml");

#[derive(Debug, Clone)]

pub struct Config {

    pub general: General,

    pub output: Outputs,

    pub decoration: Decoration,

    pub animation: Animation,

    pub keyboard: Keyboard,

    pub input: Input,

    pub idle: Idle,

    pub lid: Lid,

    pub xwayland: Xwayland,

    pub binds: Vec<Bind>,

    pub rules: Vec<Rule>,

    pub startup: Vec<Vec<String>>,

}

#[derive(Deserialize, Debug, Clone, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct General {

    /// What `Mod` means in binds.

    #[serde(rename = "mod")]

    pub mod_key: Modifier,

    pub gaps: Gaps,

    /// A new window splits the one it opens beside along that window's

    /// longer side, instead of joining its container.

    pub autotile: bool,

    /// What a window move does when it meets a neighbour.

    #[serde(rename = "move")]

    pub move_mode: MoveMode,

    pub focus_follows_mouse: bool,

    pub mouse_follows_focus: bool,

    /// The first window to land on or move to an empty tag nobody is

    /// viewing brings that tag into view on its output.

    pub view_tag_on_first_window: bool,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]

#[serde(rename_all = "lowercase")]

pub enum MoveMode {

    /// Trade places with it.

    #[default]

    Swap,

    /// Join its lane, stacking with it if it is alone.

    Merge,

}

impl Default for General {

    fn default() -> Self {

        Self {

            mod_key: Modifier::Super,

            gaps: Gaps::default(),

            autotile: true,

            move_mode: MoveMode::Swap,

            focus_follows_mouse: false,

            mouse_follows_focus: false,

            view_tag_on_first_window: true,

        }

    }

}

#[derive(Deserialize, Debug, Clone, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct Xwayland {

    /// Which X11 clients may read a Wayland-owned selection.

    pub selection_access: SelectionAccess,

}

impl Default for Xwayland {

    fn default() -> Self {

        Self {

            selection_access: SelectionAccess::Focused,

        }

    }

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "lowercase")]

pub enum SelectionAccess {

    /// Only the X11 window holding keyboard focus.

    Focused,

    /// Every X11 client, which clipboard managers and headless tools need.

    Any,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct Gaps {

    pub inner: f64,

    pub outer: f64,

}

impl Default for Gaps {

    fn default() -> Self {

        Self {

            inner: 8.0,

            outer: 8.0,

        }

    }

}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default)]

pub struct Outputs {

    pub vrr: Vrr,

    /// Settings for one connector, by name, like `DP-1`.

    #[serde(flatten)]

    pub named: std::collections::BTreeMap<String, OutputConfig>,

}

/// Transform and position follow a reload. A new mode waits for a restart

/// or a replug, since it means a modeset.

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default, deny_unknown_fields)]

pub struct OutputConfig {

    pub transform: OutputTransform,

    /// Top left corner in the global layout. Outputs without one are placed

    /// to the right of the others.

    pub position: Option<[i32; 2]>,

    /// `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`. Without a rate the highest one

    /// for that size wins.

    pub mode: Option<String>,

}

/// Counterclockwise rotation, optionally after flipping horizontally.

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]

#[serde(rename_all = "kebab-case")]

pub enum OutputTransform {

    #[default]

    Normal,

    #[serde(rename = "90")]

    Rotate90,

    #[serde(rename = "180")]

    Rotate180,

    #[serde(rename = "270")]

    Rotate270,

    Flipped,

    #[serde(rename = "flipped-90")]

    Flipped90,

    #[serde(rename = "flipped-180")]

    Flipped180,

    #[serde(rename = "flipped-270")]

    Flipped270,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]

#[serde(rename_all = "lowercase")]

pub enum Vrr {

    Off,

    On,

    /// Only while a fullscreen window is shown, where a game sets the pace.

    #[default]

    Fullscreen,

}

#[derive(Deserialize, Debug, Clone, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct Decoration {

    /// Border width in logical pixels, drawn in the gap around each window.

    pub border: u32,

    pub radius: Corners,

    pub focused: Color,

    pub unfocused: Color,

    pub urgent: Color,

}

/// Corner radii in logical pixels, top left, top right, bottom right and

/// bottom left. One number rounds every corner alike.

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]

#[serde(from = "CornersToml")]

pub struct Corners(pub [u32; 4]);

#[derive(Deserialize)]

#[serde(

    untagged,

    expecting = "expected a number or [top left, top right, bottom right, bottom left]"

)]

enum CornersToml {

    All(u32),

    Each([u32; 4]),

}

impl From<CornersToml> for Corners {

    fn from(c: CornersToml) -> Self {

        match c {

            CornersToml::All(r) => Self([r; 4]),

            CornersToml::Each(r) => Self(r),

        }

    }

}

impl Default for Decoration {

    fn default() -> Self {

        Self {

            border: 2,

            radius: Corners([0; 4]),

            focused: Color::rgb(0x88, 0xbf, 0xd1),

            unfocused: Color::rgb(0x3b, 0x42, 0x52),

            urgent: Color::rgb(0xeb, 0xcb, 0x8b),

        }

    }

}

/// Straight RGBA from `#rrggbb` or `#rrggbbaa`.

#[derive(Debug, Clone, Copy, PartialEq)]

pub struct Color(pub [f32; 4]);

impl Color {

    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {

        Self([r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0])

    }

}

impl<'de> Deserialize<'de> for Color {

    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {

        let s = String::deserialize(d)?;

        let hex = s.strip_prefix('#').unwrap_or(&s);

        let bad =

            || serde::de::Error::custom(format!("bad colour {s:?}, use #rrggbb or #rrggbbaa"));

        if !matches!(hex.len(), 6 | 8) || !hex.is_ascii() {

            return Err(bad());

        }

        let mut c = [1.0f32; 4];

        for (i, v) in c.iter_mut().enumerate().take(hex.len() / 2) {

            let byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).map_err(|_| bad())?;

            *v = f32::from(byte) / 255.0;

        }

        Ok(Self(c))

    }

}

#[derive(Deserialize, Debug, Clone, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct Animation {

    pub enabled: bool,

    pub style: AnimationStyle,

    /// Every phase of a planned transition lasts this long.

    pub phase_ms: u64,

    /// A cubic bezier, as in CSS.

    pub curve: [f64; 4],

}

impl Default for Animation {

    fn default() -> Self {

        Self {

            enabled: true,

            style: AnimationStyle::Orthogonal,

            phase_ms: 160,

            curve: [0.45, 0.0, 0.2, 1.0],

        }

    }

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "lowercase")]

pub enum AnimationStyle {

    Orthogonal,

    Direct,

}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default, deny_unknown_fields)]

pub struct Idle {

    /// Seconds without input before every output is switched off, 0 for

    /// never.

    pub blank_after: u64,

}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default, deny_unknown_fields)]

pub struct Lid {

    /// What closing the lid does while no other output is connected.

    pub close: LidAction,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]

#[serde(rename_all = "lowercase")]

pub enum LidAction {

    #[default]

    Suspend,

    Poweroff,

    /// Leave it to logind or whatever else watches the switch.

    Ignore,

}

#[derive(Deserialize, Debug, Clone, PartialEq)]

#[serde(default, deny_unknown_fields)]

pub struct Keyboard {

    pub rules: String,

    pub model: String,

    pub layout: String,

    pub variant: String,

    pub options: Option<String>,

    pub repeat_delay: i32,

    pub repeat_rate: i32,

}

impl Default for Keyboard {

    fn default() -> Self {

        Self {

            rules: String::new(),

            model: String::new(),

            layout: String::new(),

            variant: String::new(),

            options: None,

            repeat_delay: 200,

            repeat_rate: 25,

        }

    }

}

/// libinput settings for pointing devices. Unset options keep libinput's

/// default for the device.

#[derive(Debug, Clone, PartialEq, Default)]

pub struct Input {

    pub pointer: DeviceSettings,

    /// Devices that can tap, which libinput only offers on touchpads.

    pub touchpad: DeviceSettings,

    /// Overrides for devices by name, later entries winning.

    pub device: Vec<NamedDevice>,

}

#[derive(Debug, Clone, PartialEq)]

pub struct NamedDevice {

    pub name: String,

    pub settings: DeviceSettings,

}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default, deny_unknown_fields)]

pub struct DeviceSettings {

    pub accel_profile: Option<AccelProfile>,

    pub accel_speed: Option<f64>,

    /// The custom profile's curve, pointer speed sampled every `accel_step`

    /// device units per millisecond.

    pub accel_points: Option<Vec<f64>>,

    pub accel_step: Option<f64>,

    pub natural_scroll: Option<bool>,

    pub left_handed: Option<bool>,

    pub tap: Option<bool>,

    pub tap_drag: Option<bool>,

    pub tap_drag_lock: Option<bool>,

    pub dwt: Option<bool>,

    pub middle_emulation: Option<bool>,

    pub scroll_method: Option<ScrollMethod>,

    pub scroll_button: Option<u32>,

    pub click_method: Option<ClickMethod>,

    /// Applied by the compositor, libinput has no such setting.

    pub scroll_factor: Option<f64>,

}

impl DeviceSettings {

    /// `self` with every option `over` sets replaced.

    pub fn overlay(&self, over: &Self) -> Self {

        Self {

            accel_profile: over.accel_profile.or(self.accel_profile),

            accel_speed: over.accel_speed.or(self.accel_speed),

            accel_points: over

                .accel_points

                .clone()

                .or_else(|| self.accel_points.clone()),

            accel_step: over.accel_step.or(self.accel_step),

            natural_scroll: over.natural_scroll.or(self.natural_scroll),

            left_handed: over.left_handed.or(self.left_handed),

            tap: over.tap.or(self.tap),

            tap_drag: over.tap_drag.or(self.tap_drag),

            tap_drag_lock: over.tap_drag_lock.or(self.tap_drag_lock),

            dwt: over.dwt.or(self.dwt),

            middle_emulation: over.middle_emulation.or(self.middle_emulation),

            scroll_method: over.scroll_method.or(self.scroll_method),

            scroll_button: over.scroll_button.or(self.scroll_button),

            click_method: over.click_method.or(self.click_method),

            scroll_factor: over.scroll_factor.or(self.scroll_factor),

        }

    }

    fn validate(&mut self, name: &str, w: &mut Vec<String>) {

        if let Some(s) = self.accel_speed

            && !(-1.0..=1.0).contains(&s)

        {

            w.push(format!(

                "{name}.accel_speed: {s} is outside -1 to 1, ignored"

            ));

            self.accel_speed = None;

        }

        if let Some(f) = self.scroll_factor

            && !(f.is_finite() && f >= 0.0)

        {

            w.push(format!(

                "{name}.scroll_factor: {f} must be zero or more, ignored"

            ));

            self.scroll_factor = None;

        }

        if self.accel_points.is_some() != self.accel_step.is_some() {

            w.push(format!(

                "{name}: accel_points needs accel_step and the other way round, both ignored"

            ));

            self.accel_points = None;

            self.accel_step = None;

        }

    }

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "lowercase")]

pub enum AccelProfile {

    Flat,

    Adaptive,

    Custom,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "kebab-case")]

pub enum ScrollMethod {

    None,

    TwoFinger,

    Edge,

    OnButtonDown,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "kebab-case")]

pub enum ClickMethod {

    ButtonAreas,

    Clickfinger,

}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]

#[serde(rename_all = "lowercase")]

pub enum Modifier {

    Super,

    Alt,

    Ctrl,

    Shift,

}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]

pub struct Mods {

    pub logo: bool,

    pub alt: bool,

    pub ctrl: bool,

    pub shift: bool,

}

impl Mods {

    pub fn has(&self, m: Modifier) -> bool {

        match m {

            Modifier::Super => self.logo,

            Modifier::Alt => self.alt,

            Modifier::Ctrl => self.ctrl,

            Modifier::Shift => self.shift,

        }

    }

    fn set(&mut self, m: Modifier) {

        match m {

            Modifier::Super => self.logo = true,

            Modifier::Alt => self.alt = true,

            Modifier::Ctrl => self.ctrl = true,

            Modifier::Shift => self.shift = true,

        }

    }

}

#[derive(Debug, Clone, PartialEq)]