monolith

//! Window organisation without smithay. Tags with per-output views, one

//! tiling tree per output filtered by those views, floating windows,

//! scratchpads, focus, and restoring windows when an output comes back.

mod tree;

#[cfg(test)]

mod tests;

pub use monolith_planner::Rect;

pub use tree::{Axis, Dir, Tree};

use slotmap::{SlotMap, new_key_type};

use std::collections::HashMap;

new_key_type! {

    pub struct WindowId;

    pub struct TagId;

    pub struct OutputId;

}

pub const HOMELESS: &str = "homeless";

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

pub enum ExpandScope {

    Window,

    Container,

    All,

}

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

pub struct Gaps {

    pub inner: f64,

    pub outer: f64,

}

impl Default for Gaps {

    fn default() -> Self {

        Self {

            inner: 8.0,

            outer: 8.0,

        }

    }

}

#[derive(Clone, Debug)]

pub struct Window {

    pub output: Option<OutputId>,

    pub tag: TagId,

    pub floating: bool,

    pub float_rect: Option<Rect>,

    pub fullscreen: bool,

    pub sticky: bool,

    pub scratchpad: Option<usize>,

    evicted_from: Option<String>,

}

#[derive(Clone, Debug)]

pub struct Tag {

    pub name: String,

    pub urgent: bool,

}

#[derive(Clone, Debug)]

pub struct Output {

    pub name: String,

    pub area: Rect,

    pub tree: Tree<WindowId>,

    /// Viewed tags besides the homeless tag, which is always viewed.

    pub viewed: Vec<TagId>,

    /// Floating windows, bottom to top.

    pub floating: Vec<WindowId>,

}

#[derive(Clone, Debug)]

pub struct Scratchpad {

    pub name: String,

    pub windows: Vec<WindowId>,

    pub shown: Option<usize>,

    pub output: Option<OutputId>,

}

#[derive(Clone, Debug)]

struct Parked {

    tree: Tree<WindowId>,

    viewed: Vec<TagId>,

    floating: Vec<WindowId>,

    area: Rect,

}

#[derive(Clone, Debug, Default)]

pub struct Arrangement {

    /// Every tiled window on the output. Hidden ones are zero-size seeds.

    pub tiled: Vec<Placed>,

    /// Visible floating windows and shown scratchpads, bottom to top.

    pub floating: Vec<(WindowId, Rect)>,

    pub fullscreen: Option<WindowId>,

}

#[derive(Clone, Copy, Debug)]

pub struct Placed {

    pub window: WindowId,

    pub rect: Rect,

    pub visible: bool,

}

#[derive(Clone, Debug)]

pub struct Layout {

    windows: SlotMap<WindowId, Window>,

    tags: SlotMap<TagId, Tag>,

    tag_order: Vec<TagId>,

    homeless: TagId,

    outputs: SlotMap<OutputId, Output>,

    active: Option<OutputId>,

    /// Focus history, most recent last.

    history: Vec<WindowId>,

    scratchpads: Vec<Scratchpad>,

    last_scratchpad: Option<usize>,

    parked: HashMap<String, Parked>,

    pub gaps: Gaps,

}

impl Default for Layout {

    fn default() -> Self {

        let mut tags = SlotMap::with_key();

        let homeless = tags.insert(Tag {

            name: HOMELESS.into(),

            urgent: false,

        });

        Self {

            windows: SlotMap::with_key(),

            tags,

            tag_order: vec![homeless],

            homeless,

            outputs: SlotMap::with_key(),

            active: None,

            history: Vec::new(),

            scratchpads: Vec::new(),

            last_scratchpad: None,

            parked: HashMap::new(),

            gaps: Gaps::default(),

        }

    }

}

impl Layout {

    pub fn homeless(&self) -> TagId {

        self.homeless

    }

    /// Looks a tag up by name, creating it at the end of the order.

    pub fn tag(&mut self, name: &str) -> TagId {

        if let Some(id) = self.tag_id(name) {

            return id;

        }

        let id = self.tags.insert(Tag {

            name: name.into(),

            urgent: false,

        });

        self.tag_order.push(id);

        id

    }

    pub fn tag_id(&self, name: &str) -> Option<TagId> {

        self.tag_order

            .iter()

            .copied()

            .find(|&t| self.tags[t].name == name)

    }

    pub fn tags(&self) -> impl Iterator<Item = (TagId, &Tag)> {

        self.tag_order.iter().map(|&t| (t, &self.tags[t]))

    }

    pub fn reorder_tag(&mut self, tag: TagId, index: usize) {

        if let Some(i) = self.tag_order.iter().position(|&t| t == tag) {

            self.tag_order.remove(i);

            let index = index.min(self.tag_order.len());

            self.tag_order.insert(index, tag);

        }

    }

    pub fn window(&self, w: WindowId) -> Option<&Window> {

        self.windows.get(w)

    }

    pub fn windows(&self) -> impl Iterator<Item = (WindowId, &Window)> {

        self.windows.iter()

    }

    pub fn output(&self, o: OutputId) -> Option<&Output> {

        self.outputs.get(o)

    }

    pub fn outputs(&self) -> impl Iterator<Item = (OutputId, &Output)> {

        self.outputs.iter()

    }

    pub fn scratchpads(&self) -> &[Scratchpad] {

        &self.scratchpads

    }

    pub fn active_output(&self) -> Option<OutputId> {

        self.active

    }

    pub fn set_active_output(&mut self, o: OutputId) {

        if self.outputs.contains_key(o) {

            self.active = Some(o);

        }

    }

    /// Adds an output. One that was unplugged before gets back its tree,

    /// views and the windows that had to leave it.

    pub fn add_output(&mut self, name: &str, area: Rect) -> OutputId {

        let id = self.outputs.insert(Output {

            name: name.into(),

            area,

            tree: Tree::default(),

            viewed: Vec::new(),

            floating: Vec::new(),

        });

        if let Some(parked) = self.parked.remove(name) {

            self.restore(id, parked);

        }

        self.active.get_or_insert(id);

        let detached: Vec<WindowId> = self

            .windows

            .iter()

            .filter(|(_, w)| w.output.is_none())

            .map(|(id, _)| id)

            .collect();

        for w in detached {

            self.windows[w].output = Some(id);

            self.place(w);

        }

        id

    }

    fn restore(&mut self, id: OutputId, parked: Parked) {

        let name = self.outputs[id].name.clone();

        let ours = |l: &Self, w: WindowId| {

            l.windows

                .get(w)

                .is_some_and(|x| x.evicted_from.as_deref() == Some(&name) && x.scratchpad.is_none())

        };

        let mut tree = parked.tree;

        tree.retain(|w| ours(self, w) && !self.windows[w].floating);

        let floating: Vec<WindowId> = parked

            .floating

            .into_iter()

            .filter(|&w| ours(self, w) && self.windows[w].floating)

            .collect();

        for w in tree

            .windows()

            .chain(floating.iter().copied())

            .collect::<Vec<_>>()

        {

            self.unplace(w);

            let win = &mut self.windows[w];

            if let (Some(from), Some(rect)) = (win.output, win.float_rect) {

                win.float_rect = Some(translate(rect, self.outputs[from].area, parked.area));

            }

            win.output = Some(id);

            win.evicted_from = None;

        }

        let out = &mut self.outputs[id];

        out.tree = tree;

        out.floating = floating;

        out.viewed = parked

            .viewed

            .into_iter()

            .filter(|&t| self.tags.contains_key(t))

            .collect();

    }

    /// Removes an output. Its windows move to an output viewing their tag,

    /// or the active one, and remember where they came from.

    pub fn remove_output(&mut self, o: OutputId) {

        let Some(out) = self.outputs.remove(o) else {

            return;

        };

        self.parked.insert(

            out.name.clone(),

            Parked {

                tree: out.tree,

                viewed: out.viewed,

                floating: out.floating,

                area: out.area,

            },

        );

        if self.active == Some(o) {

            self.active = self.outputs.keys().next();

        }

        for sp in &mut self.scratchpads {

            if sp.output == Some(o) {

                sp.output = self.active;

            }

        }

        let leaving: Vec<WindowId> = self

            .windows

            .iter()

            .filter(|(_, w)| w.output == Some(o))

            .map(|(id, _)| id)

            .collect();

        for w in leaving {

            let tag = self.windows[w].tag;

            let target = self

                .outputs

                .keys()

                .find(|&t| self.is_viewed(t, tag))

                .or(self.active);

            let win = &mut self.windows[w];

            if let (Some(t), Some(rect)) = (target, win.float_rect) {

                win.float_rect = Some(translate(rect, out.area, self.outputs[t].area));

            }

            win.output = target;

            if win.scratchpad.is_some() {

                continue;

            }

            win.evicted_from = Some(out.name.clone());

            if target.is_some() {

                self.place(w);

            }

        }

    }

    pub fn set_output_area(&mut self, o: OutputId, area: Rect) {

        if let Some(out) = self.outputs.get_mut(o) {

            out.area = area;

        }

    }

    pub fn is_viewed(&self, o: OutputId, tag: TagId) -> bool {

        tag == self.homeless

            || self

                .outputs

                .get(o)

                .is_some_and(|out| out.viewed.contains(&tag))

    }

    /// Views `tag` alone, besides the homeless tag.

    pub fn view(&mut self, o: OutputId, tag: TagId) {

        let Some(out) = self.outputs.get_mut(o) else {

            return;

        };

        out.viewed.clear();

        if tag != self.homeless {

            out.viewed.push(tag);

        }

        self.tags[tag].urgent = false;

    }

    pub fn toggle_view(&mut self, o: OutputId, tag: TagId) {

        if tag == self.homeless {

            return;

        }

        let Some(out) = self.outputs.get_mut(o) else {

            return;

        };

        if let Some(i) = out.viewed.iter().position(|&t| t == tag) {

            out.viewed.remove(i);

        } else {

            out.viewed.push(tag);

            self.tags[tag].urgent = false;

        }

    }

    /// The tag a launch from `o` belongs to. The focused window's tag, else

    /// the first viewed tag, else homeless. Homeless is always on screen, so

    /// focusing one of its windows does not mean the user left their tag.

    pub fn launch_tag(&self, o: OutputId) -> TagId {

        self.focused_on(o)

            .map(|w| &self.windows[w])

            .filter(|w| w.scratchpad.is_none() && !w.sticky && w.tag != self.homeless)

            .map(|w| w.tag)

            .or_else(|| self.outputs.get(o)?.viewed.first().copied())

            .unwrap_or(self.homeless)

    }

    pub fn view_everywhere(&mut self, tag: TagId) {

        for o in self.outputs.keys().collect::<Vec<_>>() {

            self.view(o, tag);

        }

    }

    pub fn visible(&self, w: WindowId) -> bool {

        let Some(win) = self.windows.get(w) else {

            return false;

        };

        let Some(o) = win.output else {

            return false;

        };

        match win.scratchpad {

            Some(s) => {

                let sp = &self.scratchpads[s];

                sp.output == Some(o) && sp.shown.map(|i| sp.windows[i]) == Some(w)

            }

            None => win.sticky || self.is_viewed(o, win.tag),

        }

    }

    /// Adds a window on `output` (default the active one) and `tag` (default

    /// homeless). A window landing on a tag its output is not viewing marks

    /// the tag urgent.

    pub fn add_window(

        &mut self,

        output: Option<OutputId>,

        tag: Option<TagId>,

        floating: Option<Rect>,

    ) -> WindowId {

        let output = output

            .filter(|&o| self.outputs.contains_key(o))

            .or(self.active);

        let tag = tag

            .filter(|&t| self.tags.contains_key(t))

            .unwrap_or(self.homeless);

        let w = self.windows.insert(Window {

            output,

            tag,

            floating: floating.is_some(),

            float_rect: floating,

            fullscreen: false,

            sticky: false,

            scratchpad: None,

            evicted_from: None,

        });

        if let Some(o) = output {

            if !self.is_viewed(o, tag) {

                self.tags[tag].urgent = true;

            }

            self.place(w);

        }

        w

    }

    pub fn remove_window(&mut self, w: WindowId) {

        if !self.windows.contains_key(w) {

            return;

        }

        self.unplace(w);

        self.history.retain(|&h| h != w);

        if let Some(s) = self.windows[w].scratchpad {

            self.leave_scratchpad(s, w);

        }

        self.windows.remove(w);

    }

    /// Puts a window into its output's tree or floating stack. Tiled windows

    /// go next to the focused window if both are visible, else next to the

    /// latest window of their tag, else into a new row.

    fn place(&mut self, w: WindowId) {

        let win = &self.windows[w];

        let Some(o) = win.output else { return };

        if win.scratchpad.is_some() {

            return;

        }

        if win.floating {

            if win.float_rect.is_none() {

                let rect = centred(self.outputs[o].area, 0.6);

                self.windows[w].float_rect = Some(rect);

            }

            self.outputs[o].floating.push(w);

            return;

        }

        let tag = win.tag;

        let tree = &self.outputs[o].tree;

        let focused = self

            .focused()

            .filter(|&f| tree.contains(f) && self.is_viewed(o, tag));

        let anchor = focused.or_else(|| {

            self.history

                .iter()

                .rev()