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 outputs;

mod scratchpad;

mod tree;

#[cfg(test)]

mod tests;

pub use monolith_planner::Rect;

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

use outputs::Parked;

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,

}

/// Space taken from an output's edges by bars and other panels.

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

pub struct Insets {

    pub top: f64,

    pub right: f64,

    pub bottom: f64,

    pub left: f64,

}

#[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 reserved: Insets,

    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, 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);

        }

    }

    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()

                .copied()

                .find(|&h| tree.contains(h) && self.windows[h].tag == tag)

        });

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

        match anchor {

            Some(a) => tree.insert_after(w, a),

            None => tree.insert_row(w),

        }

    }

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

        let Some(o) = self.windows[w].output else {

            return;

        };

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

        out.tree.remove(w);

        out.floating.retain(|&f| f != w);

    }

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

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

            return;

        };

        self.active = win.output.or(self.active);

        if let Some(o) = win.output {

            let stack = &mut self.outputs[o].floating;

            if let Some(i) = stack.iter().position(|&f| f == w) {

                stack.remove(i);

                stack.push(w);

            }

        }

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

        self.history.push(w);

    }

    /// The most recently focused visible window.

    pub fn focused(&self) -> Option<WindowId> {

        self.history

            .iter()

            .rev()

            .copied()

            .find(|&w| self.visible(w))

    }

    /// The most recently focused visible window on `o`.

    pub fn focused_on(&self, o: OutputId) -> Option<WindowId> {

        self.history

            .iter()

            .rev()

            .copied()

            .find(|&w| self.windows[w].output == Some(o) && self.visible(w))

    }

    /// Focuses the nearest visible window in `dir`, crossing to the next

    /// output when there is none on this one.

    pub fn focus_dir(&mut self, dir: Dir) -> Option<WindowId> {

        let o = self.active?;

        let from = self.focused_on(o).and_then(|f| self.rect_of(f));

        let target = from.and_then(|from| {

            let arr = self.arrange(o);

            let candidates = arr

                .tiled

                .iter()

                .filter(|p| p.visible)

                .map(|p| (p.window, p.rect))

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

                .filter(|&(w, _)| Some(w) != self.focused_on(o));

            nearest(from, dir, candidates)

        });

        if let Some(w) = target {

            self.focus(w);

            return Some(w);

        }

        let next = self.output_towards(o, dir)?;

        self.active = Some(next);

        let w = self.focused_on(next);

        if let Some(w) = w {

            self.focus(w);

        }

        w

    }

    pub fn output_towards(&self, from: OutputId, dir: Dir) -> Option<OutputId> {

        let here = self.outputs.get(from)?.area;

        let others = self

            .outputs

            .iter()

            .filter(|&(id, _)| id != from)

            .map(|(id, out)| (id, out.area));

        nearest(here, dir, others)

    }

    fn rect_of(&self, w: WindowId) -> Option<Rect> {

        let o = self.windows.get(w)?.output?;

        let arr = self.arrange(o);

        arr.tiled

            .iter()

            .find(|p| p.window == w)

            .map(|p| p.rect)

            .or_else(|| arr.floating.iter().find(|f| f.0 == w).map(|f| f.1))

    }

    fn vis_on(&self, o: OutputId) -> impl Fn(WindowId) -> bool + '_ {

        move |w| self.windows[w].output == Some(o) && self.visible(w)

    }

    fn focused_tiled(&self) -> Option<(WindowId, OutputId)> {

        let w = self.focused()?;

        let o = self.windows[w].output?;

        self.outputs[o].tree.contains(w).then_some((w, o))

    }

    pub fn move_window(&mut self, dir: Dir) -> bool {

        let Some((w, o)) = self.focused_tiled() else {