penrose 0.4.0

A tiling window manager library inspired by dwm and xmonad
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::pure::{
    geometry::{Rect, RelativeRect},
    Stack, Workspace,
};
use std::{collections::HashMap, fmt, hash::Hash};

/// A wrapper around a single [Workspace] that includes the physical screen
/// size as a [Rect].
#[derive(Default, Debug, Clone)]
pub struct Screen<C> {
    pub(crate) index: usize,
    /// The [Workspace] current visible on this screen
    pub workspace: Workspace<C>,
    pub(crate) r: Rect,
}

impl<C: fmt::Display> fmt::Display for Screen<C> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Screen({}: {:?}):\n  - workspace: {}",
            self.index, self.r, self.workspace
        )
    }
}

impl<C> Screen<C> {
    /// The index of this screen.
    ///
    /// Indices are assigned from left to right based on the absolute position of
    /// their top left corner.
    pub fn index(&self) -> usize {
        self.index
    }

    /// The physical screen size of this [Screen] as a [Rect].
    pub fn geometry(&self) -> Rect {
        self.r
    }
}

impl<C> Screen<C>
where
    C: Clone + Eq + Hash,
{
    /// Produce a summary of the clients contained within this screen
    pub fn screen_clients(&self, floating: &HashMap<C, RelativeRect>) -> ScreenClients<C> {
        ScreenClients {
            floating: self
                .workspace
                .clients()
                .flat_map(|c| floating.get(c).map(|r| (c.clone(), *r)))
                .collect(),
            tiling: self
                .workspace
                .stack
                .as_ref()
                .and_then(|st| st.from_filtered(|c| !floating.contains_key(c))),
            tag: self.workspace.tag.clone(),
            r_s: self.r,
        }
    }
}

/// Used in laying out visible_client_positions
#[derive(Debug)]
pub struct ScreenClients<C> {
    /// Floating client positions on this screen
    pub floating: Vec<(C, RelativeRect)>,
    /// Clients that need to be tiled on this screen
    pub tiling: Option<Stack<C>>,
    /// The workspace tag currently visible on this screen
    pub tag: String,
    /// The dimensions of this screen
    pub r_s: Rect,
}