monolith

//! The control protocol. Newline-delimited JSON over a unix socket, one

//! message per line, each carrying the protocol version `v`.

//!

//! Commands also have a word form, `focus left` or `spawn beer`, shared by

//! the CLI and keybindings in the config.

use serde::{Deserialize, Serialize};

use std::fmt;

use std::path::PathBuf;

pub const VERSION: u32 = 1;

/// Where the compositor serving `display` listens.

pub fn socket_path_for(display: &str) -> Option<PathBuf> {

    let dir = std::env::var_os("XDG_RUNTIME_DIR")?;

    Some(PathBuf::from(dir).join(format!("monolith-{display}.sock")))

}

/// Where a client should connect. `$MONOLITH_SOCKET`, else the socket of

/// the compositor serving `$WAYLAND_DISPLAY`.

pub fn socket_path() -> Option<PathBuf> {

    if let Some(p) = std::env::var_os("MONOLITH_SOCKET") {

        return Some(p.into());

    }

    socket_path_for(&std::env::var("WAYLAND_DISPLAY").ok()?)

}

pub use monolith_layout::{Axis, Dir};

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

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

pub enum ExpandScope {

    #[default]

    Window,

    Container,

}

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

#[serde(tag = "command", rename_all = "kebab-case", deny_unknown_fields)]

pub enum Command {

    Spawn {

        argv: Vec<String>,

    },

    Close,

    Quit,

    Reload,

    Focus {

        dir: Dir,

    },

    /// Focuses the latest window on the other layer, floating or tiled.

    FocusLayer,

    Move {

        dir: Dir,

    },

    MoveContainer {

        dir: Dir,

    },

    Resize {

        axis: Axis,

        delta: f64,

    },

    /// Shares the focused window's block equally among its children.

    BalanceBlock,

    Expand {

        scope: ExpandScope,

    },

    /// Expands every container above the focused window towards it.

    Maximize,

    /// Makes the next window move do the opposite of the configured default,

    /// swap or merge. Again before moving cancels it.

    InvertMove,

    Flip,

    Float,

    Fullscreen,

    Sticky,

    View {

        tag: String,

    },

    ToggleView {

        tag: String,

    },

    ViewEverywhere {

        tag: String,

    },

    /// Sends the focused window to a tag.

    Tag {

        tag: String,

    },

    ReorderTag {

        tag: String,

        index: usize,

    },

    FocusOutput {

        dir: Dir,

    },

    SendToOutput {

        dir: Dir,

    },

    /// Adds the focused window to a scratchpad.

    Scratchpad {

        name: String,

    },

    Summon {

        name: String,

    },

    Dismiss {

        name: Option<String>,

    },

    /// Switches outputs on or off, all of them without a name.

    Power {

        on: bool,

        #[serde(default)]

        output: Option<String>,

    },

}

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

pub struct ParseError(pub String);

impl fmt::Display for ParseError {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.write_str(&self.0)

    }

}

impl std::error::Error for ParseError {}

impl Command {

    /// Whether a bind running this still fires on a locked session, which

    /// leaves out everything that moves focus, windows or tags, and quitting.

    pub fn allowed_while_locked(&self) -> bool {

        matches!(self, Command::Spawn { .. } | Command::Reload)

    }

    /// Parses the word form, as in `["move-container", "left"]`.

    pub fn parse<S: AsRef<str>>(words: &[S]) -> Result<Self, ParseError> {

        let words: Vec<&str> = words.iter().map(AsRef::as_ref).collect();

        let Some((&name, args)) = words.split_first() else {

            return Err(ParseError("empty command".into()));

        };

        let err = |m: &str| ParseError(format!("{name}: {m}"));

        let one = || match args {

            [a] => Ok(a.to_string()),

            _ => Err(err("takes exactly one argument")),

        };

        let none = |c: Command| {

            if args.is_empty() {

                Ok(c)

            } else {

                Err(err("takes no arguments"))

            }

        };

        let dir = || -> Result<Dir, ParseError> {

            match one()?.as_str() {

                "left" | "h" => Ok(Dir::Left),

                "right" | "l" => Ok(Dir::Right),

                "up" | "k" => Ok(Dir::Up),

                "down" | "j" => Ok(Dir::Down),

                d => Err(err(&format!("unknown direction {d}"))),

            }

        };

        Ok(match name {

            "spawn" if !args.is_empty() => Command::Spawn {

                argv: args.iter().map(|a| a.to_string()).collect(),

            },

            "spawn" => return Err(err("needs a program")),

            "close" => none(Command::Close)?,

            "quit" => none(Command::Quit)?,

            "reload" => none(Command::Reload)?,

            "flip" => none(Command::Flip)?,

            "maximize" => none(Command::Maximize)?,

            "invert-move" => none(Command::InvertMove)?,

            "balance-block" => none(Command::BalanceBlock)?,

            "float" => none(Command::Float)?,

            "fullscreen" => none(Command::Fullscreen)?,

            "sticky" => none(Command::Sticky)?,

            "focus" => Command::Focus { dir: dir()? },

            "focus-layer" => none(Command::FocusLayer)?,

            "move" => Command::Move { dir: dir()? },

            "move-container" => Command::MoveContainer { dir: dir()? },

            "focus-output" => Command::FocusOutput { dir: dir()? },

            "send-to-output" => Command::SendToOutput { dir: dir()? },

            "resize" => {

                let [axis, delta] = args else {

                    return Err(err("takes an axis and a delta"));

                };

                let axis = match *axis {

                    "horizontal" | "h" => Axis::Horizontal,

                    "vertical" | "v" => Axis::Vertical,

                    a => return Err(err(&format!("unknown axis {a}"))),

                };

                let delta = delta

                    .parse()

                    .map_err(|_| err(&format!("bad delta {delta}")))?;

                Command::Resize { axis, delta }

            }

            "expand" => Command::Expand {

                scope: match args {

                    [] | ["window"] => ExpandScope::Window,

                    ["container"] => ExpandScope::Container,

                    _ => return Err(err("takes window or container")),

                },

            },

            "view" => Command::View { tag: one()? },

            "toggle-view" => Command::ToggleView { tag: one()? },

            "view-everywhere" => Command::ViewEverywhere { tag: one()? },

            "tag" => Command::Tag { tag: one()? },

            "reorder-tag" => {

                let [tag, index] = args else {

                    return Err(err("takes a tag and an index"));

                };

                let index = index

                    .parse()

                    .map_err(|_| err(&format!("bad index {index}")))?;

                Command::ReorderTag {

                    tag: tag.to_string(),

                    index,

                }

            }

            "scratchpad" => Command::Scratchpad { name: one()? },

            "summon" => Command::Summon { name: one()? },

            "dismiss" => Command::Dismiss {

                name: match args {

                    [] => None,

                    [n] => Some(n.to_string()),

                    _ => return Err(err("takes at most one name")),

                },

            },

            "power" => {

                let (on, output) = match args {

                    ["on"] => (true, None),

                    ["off"] => (false, None),

                    ["on", o] => (true, Some(o.to_string())),

                    ["off", o] => (false, Some(o.to_string())),

                    _ => return Err(err("takes on or off and optionally an output")),

                };

                Command::Power { on, output }

            }

            _ => return Err(ParseError(format!("unknown command {name}"))),

        })

    }

}

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

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

pub enum Request {

    Run(Command),

    Get(Query),

    /// Streams a `State` event after every change until the client hangs up.

    Subscribe {},

}

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

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

pub enum Query {

    State,

    Version,

    Warnings,

}

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

pub struct Envelope<T> {

    pub v: u32,

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub id: Option<u64>,

    #[serde(flatten)]

    pub body: T,

}

impl<T> Envelope<T> {

    pub fn new(id: Option<u64>, body: T) -> Self {

        Self {

            v: VERSION,

            id,

            body,

        }

    }

}

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

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

pub enum Reply {

    Ok(Option<Answer>),

    Error(String),

    Event(State),

}

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

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

pub enum Answer {

    State(State),

    Version(String),

    Warnings(Vec<String>),

}

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

pub struct State {

    /// The next window move does the opposite of the configured default.

    pub move_inverted: bool,

    pub tags: Vec<Tag>,

    pub outputs: Vec<Output>,

    pub windows: Vec<Window>,

}

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

pub struct Tag {

    pub name: String,

    pub urgent: bool,

}

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

pub struct Output {

    pub name: String,

    /// x, y, width, height in logical pixels.

    pub area: [f64; 4],

    pub viewed: Vec<String>,

    pub active: bool,

}

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

pub struct Window {

    pub id: u64,

    pub app_id: String,

    pub title: String,

    pub tag: String,

    pub output: Option<String>,

    /// x, y, width, height in logical pixels, while placed on an output.

    #[serde(default)]

    pub area: Option<[f64; 4]>,

    pub floating: bool,

    pub fullscreen: bool,

    pub sticky: bool,

    pub scratchpad: Option<String>,

    pub visible: bool,

    pub focused: bool,

    pub urgent: bool,

}