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

use crate::it::test_error::TestResult;
use crate::rect::Rect;
use crate::tree::ContainerChild;
use crate::tree::ContainerChildType;
use crate::tree::ContainerNode;
use crate::tree::NodeBase;
use crate::tree::NodeId;
use crate::tree::ToplevelNode;
use crate::tree::TreeTimeline::LiveTL;
use crate::utils::linkedlist::NodeRef;
use std::rc::Rc;

pub trait TestContainerExt {
    fn first_toplevel(&self) -> TestResult<Rc<dyn ToplevelNode>>;
    fn is_mono(&self) -> bool;
    fn child_ids(&self) -> Vec<NodeId>;
    fn child_body(&self, tl: &dyn ToplevelNode) -> TestResult<Rect>;
    fn child_title_rect(&self, tl: &dyn ToplevelNode) -> TestResult<Rect>;
    fn child_title_offsets(&self, tl: &dyn ToplevelNode) -> TestResult<(i32, i32, i32)>;
    fn child_ty(&self, tl: &dyn ToplevelNode) -> TestResult<ContainerChildType>;
    fn child_is_visible(&self, tl: &dyn ToplevelNode) -> TestResult<bool>;
}

fn child<T>(
    c: &ContainerNode,
    tl: &dyn ToplevelNode,
    f: impl FnOnce(&NodeRef<ContainerChild>) -> T,
) -> TestResult<T> {
    for node in c.children.iter_valid(LiveTL) {
        if node.node.node_id() == tl.node_id() {
            return Ok(f(&node));
        }
    }
    bail!(
        "Toplevel {} is not a child of container {}",
        tl.node_id(),
        c.node_id(),
    )
}

impl TestContainerExt for ContainerNode {
    fn first_toplevel(&self) -> TestResult<Rc<dyn ToplevelNode>> {
        match self.children.first() {
            None => bail!("container does not have children"),
            Some(c) => Ok(c.node.clone()),
        }
    }

    fn is_mono(&self) -> bool {
        self.node_state[LiveTL].mono_child.get().is_some()
    }

    fn child_ids(&self) -> Vec<NodeId> {
        self.children
            .iter_valid(LiveTL)
            .map(|c| c.node.node_id())
            .collect()
    }

    fn child_body(&self, tl: &dyn ToplevelNode) -> TestResult<Rect> {
        child(self, tl, |c| c.node_state[LiveTL].body.get())
    }

    fn child_title_rect(&self, tl: &dyn ToplevelNode) -> TestResult<Rect> {
        child(self, tl, |c| c.node_state[LiveTL].title_rect.get())
    }

    fn child_title_offsets(&self, tl: &dyn ToplevelNode) -> TestResult<(i32, i32, i32)> {
        child(self, tl, |c| {
            let offsets = &c.node_state[LiveTL].offsets;
            (
                offsets.overlay_icon.get(),
                offsets.toplevel_icon.get(),
                offsets.title.get(),
            )
        })
    }

    fn child_ty(&self, tl: &dyn ToplevelNode) -> TestResult<ContainerChildType> {
        child(self, tl, |c| c.node_state[LiveTL].ty.get())
    }

    fn child_is_visible(&self, tl: &dyn ToplevelNode) -> TestResult<bool> {
        child(self, tl, |c| c.node.node_visible(LiveTL))
    }
}