jay-compositor 1.15.0

The Jay compositor
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

/*
dir dfs_node_seat_state (global) {
    no_focus_history: reg,
}

dir dfs_node (abstract, global) {
    node_type: reg,
    node_id: reg,
    node_seat_state: view (key = 0),
    node_visible: reg,
    node_absolute_position: reg,
    node_output: link (opt),
    node_workspace: link (opt),
    node_layer: reg,
    node_accepts_focus: reg,
    node_client: link (opt),
}

dir node {
    @inherit dfs_node,
}
 */
use crate::dfs::dfs_helpers::dfs_split_view;
use crate::dfs::dfs_helpers::format_client_link;
use crate::dfs::dfs_helpers::format_output_link;
use crate::dfs::dfs_helpers::format_workspace_link;
use crate::tree::Node;
use crate::tree::tree_dfs_g_fuse::generated::node;
use crate::utils::fuse::fuse_globals::dfs_node;
use crate::utils::fuse::fuse_globals::dfs_node_seat_state;
use crate::utils::static_text::StaticText;
use crate::utils::str_fmt::StrCtx;
use crate::utils::str_fmt::StrFmt;
pub use node::View as NodeView;
use std::any::type_name;

impl<T> dfs_node::Dir for T
where
    T: Node,
{
    type ViewNodeSeatState = dfs_node_seat_state::View;

    fn read_node_type(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        type_name::<T>().str_fmt(buf, ctx);
    }

    fn read_node_id(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        self.node_id().raw().str_fmt(buf, ctx);
    }

    fn read_node_visible(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        dfs_split_view(buf, ctx, |v| self.node_visible(v));
    }

    fn read_node_absolute_position(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        dfs_split_view(buf, ctx, |v| self.node_absolute_position(v));
    }

    fn has_node_output(&self) -> bool {
        self.node_output_id().is_some()
    }

    fn readlink_node_output(&self, depth: u64, buf: &mut String) {
        if let Some(output) = self.node_output() {
            format_output_link(buf, depth, &output.global);
        }
    }

    fn has_node_workspace(&self) -> bool {
        self.node_workspace().is_some()
    }

    fn readlink_node_workspace(&self, depth: u64, buf: &mut String) {
        if let Some(ws) = self.node_workspace() {
            format_workspace_link(buf, depth, &ws);
        }
    }

    fn read_node_layer(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        self.node_layer().layer().text().str_fmt(buf, ctx);
    }

    fn read_node_accepts_focus(&self, buf: &mut String, ctx: &StrCtx<'_>) {
        self.node_accepts_focus().str_fmt(buf, ctx);
    }

    fn has_node_client(&self) -> bool {
        self.node_client_id().is_some()
    }

    fn readlink_node_client(&self, depth: u64, buf: &mut String) {
        if let Some(id) = self.node_client_id() {
            format_client_link(buf, depth, id);
        }
    }
}

impl<T> node::Dir for T where T: Node {}

// FUSE GENERATED START
include!(concat!(
    env!("OUT_DIR"),
    "/fuse/m_7fb9f2b988e6f084399e05fef8de29f57e7cdad26830bb7d02986a6d267eff67.rs",
));
// FUSE GENERATED STOP