yabai 0.5.0

A crate for communicating with the yabai tiling window manager.
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use serde::{Deserialize, Serialize};
use strum_macros::Display;

#[cfg(feature = "python")]
use pyo3::prelude::*;

/// An **enum** representing a command that can be sent to yabai.
///
/// Used with the `yabai::send_command` function.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "python", pyclass)]
pub enum Command {
    FocusSpace { option: FocusSpaceOption },
    RotateSpace { rotation: SpaceRotation },
    BalanceSpace {},
    MoveActiveWindowToSpace { space: u32 },
    FocusWindow { window: u32 },
    FocusWindowDirection { direction: Direction },
    SwapWindowDirection { direction: Direction },
    WarpWindowDirection { direction: Direction },
    ToggleWindowFloating {},
    ToggleZoomFullscreen {},
}

/// An **enum** representing the options passed to the `space --focus` command.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Display)]
#[cfg_attr(feature = "python", pyclass)]
pub enum FocusSpaceOption {
    #[strum(serialize = "next")]
    Next {},
    #[strum(serialize = "prev")]
    Prev {},
    #[strum(serialize = "first")]
    First {},
    #[strum(serialize = "last")]
    Last {},
    #[strum(serialize = "recent")]
    Recent {},
    Space {
        space: u32,
    },
}

/// An **enum** representing the options passed to the `space --rotate` command.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Display)]
#[cfg_attr(feature = "python", pyclass)]
pub enum SpaceRotation {
    #[strum(serialize = "90")]
    Rotate90,
    #[strum(serialize = "180")]
    Rotate180,
    #[strum(serialize = "270")]
    Rotate270,
}

/// An **enum** representing a cardinal direction.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Display)]
#[cfg_attr(feature = "python", pyclass)]
pub enum Direction {
    #[strum(serialize = "north")]
    North,
    #[strum(serialize = "south")]
    South,
    #[strum(serialize = "east")]
    East,
    #[strum(serialize = "west")]
    West,
}

/// Information about a mission control space.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[cfg_attr(feature = "python", pyclass)]
pub struct SpaceInfo {
    pub id: u32,
    pub uuid: String,
    pub index: u32,
    pub label: String,
    pub r#type: String,
    pub display: u32,
    pub windows: Vec<u32>,
    pub first_window: u32,
    pub last_window: u32,
    pub has_focus: bool,
    pub is_visible: bool,
    pub is_native_fullscreen: bool,
}

/// Information about a display.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "python", pyclass)]
pub struct DisplayInfo {
    pub id: u32,
    pub uuid: String,
    pub index: u32,
    pub frame: Frame,
    pub spaces: Vec<u32>,
}

/// Information about a window.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "kebab-case")]
#[cfg_attr(feature = "python", pyclass)]
pub struct WindowInfo {
    pub id: u32,
    pub pid: u32,
    pub app: String,
    pub title: String,
    pub frame: Frame,
    pub role: String,
    pub subrole: String,
    pub display: u32,
    pub space: u32,
    pub level: i32,
    pub layer: String,
    pub opacity: f32,
    pub split_type: String,
    pub split_child: String,
    pub stack_index: u32,
    pub can_move: bool,
    pub can_resize: bool,
    pub has_focus: bool,
    pub has_shadow: bool,
    pub has_parent_zoom: bool,
    pub has_fullscreen_zoom: bool,
    pub is_native_fullscreen: bool,
    pub is_visible: bool,
    pub is_minimized: bool,
    pub is_hidden: bool,
    pub is_floating: bool,
    pub is_sticky: bool,
    pub is_grabbed: bool,
}

/// A rectangle representing the position and size of a window or display.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "python", pyclass)]
pub struct Frame {
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
}