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

use crate::ifs::wl_seat::tablet::PadButtonState;
use crate::ifs::wl_seat::tablet::TabletPad;
use crate::tree::Node;
use crate::utils::clonecell::CloneCell;
use crate::utils::smallmap::SmallMap;
use std::rc::Rc;

pub struct PadOwnerHolder {
    default: Rc<DefaultPadOwner>,
    owner: CloneCell<Rc<dyn PadOwner>>,
}

trait PadOwner {
    fn revert_to_default(&self, pad: &Rc<TabletPad>, time_usec: u64);
    fn update_node(&self, pad: &Rc<TabletPad>);
    fn button(&self, pad: &Rc<TabletPad>, time_usec: u64, button: u32, state: PadButtonState);
}

struct DefaultPadOwner;

struct GrabPadOwner {
    buttons: SmallMap<u32, (), 4>,
    node: Rc<dyn Node>,
}

impl Default for PadOwnerHolder {
    fn default() -> Self {
        let default = Rc::new(DefaultPadOwner);
        Self {
            owner: CloneCell::new(default.clone()),
            default,
        }
    }
}

impl PadOwnerHolder {
    pub fn update_node(&self, pad: &Rc<TabletPad>) {
        self.owner.get().update_node(pad);
    }

    pub fn destroy(&self, pad: &Rc<TabletPad>) {
        self.owner
            .get()
            .revert_to_default(pad, pad.seat.state.now_usec());
        let prev = pad.node.set(pad.seat.state.root.clone());
        prev.node_on_tablet_pad_leave(pad);
        prev.node_seat_state().remove_tablet_pad_focus(pad);
    }

    pub fn button(&self, pad: &Rc<TabletPad>, time_usec: u64, button: u32, state: PadButtonState) {
        self.owner.get().button(pad, time_usec, button, state);
    }

    pub fn focus_root(&self, pad: &Rc<TabletPad>) {
        self.owner
            .get()
            .revert_to_default(pad, pad.seat.state.now_usec());
        let node = pad.seat.state.root.clone();
        pad.focus_node(node);
    }

    fn set_default_owner(&self) {
        self.owner.set(self.default.clone());
    }
}

impl TabletPad {
    fn focus_node(self: &Rc<Self>, node: Rc<dyn Node>) {
        let prev = self.node.set(node.clone());
        if node.node_id() != prev.node_id() {
            prev.node_on_tablet_pad_leave(self);
            prev.node_seat_state().remove_tablet_pad_focus(self);
            node.node_seat_state().add_tablet_pad_focus(self);
            node.node_on_tablet_pad_enter(self);
        }
    }
}

impl PadOwner for DefaultPadOwner {
    fn revert_to_default(&self, _pad: &Rc<TabletPad>, _time_usec: u64) {
        // nothing
    }

    fn update_node(&self, pad: &Rc<TabletPad>) {
        let node = pad.seat.keyboard_node.get();
        pad.focus_node(node);
    }

    fn button(&self, pad: &Rc<TabletPad>, time_usec: u64, button: u32, state: PadButtonState) {
        if state != PadButtonState::Pressed {
            return;
        }
        let node = pad.node.get();
        let owner = Rc::new(GrabPadOwner {
            buttons: Default::default(),
            node,
        });
        pad.pad_owner.owner.set(owner.clone());
        owner.button(pad, time_usec, button, state);
    }
}

impl PadOwner for GrabPadOwner {
    fn revert_to_default(&self, pad: &Rc<TabletPad>, time_usec: u64) {
        for (button, _) in &self.buttons {
            self.node
                .node_on_tablet_pad_button(pad, time_usec, button, PadButtonState::Released);
        }
        pad.pad_owner.set_default_owner();
    }

    fn update_node(&self, _pad: &Rc<TabletPad>) {
        // nothing
    }

    fn button(&self, pad: &Rc<TabletPad>, time_usec: u64, button: u32, state: PadButtonState) {
        match state {
            PadButtonState::Released => {
                if self.buttons.remove(&button).is_none() {
                    return;
                }
            }
            PadButtonState::Pressed => {
                if self.buttons.insert(button, ()).is_some() {
                    return;
                }
            }
        }
        self.node
            .node_on_tablet_pad_button(pad, time_usec, button, state);
        if self.buttons.is_empty() {
            pad.pad_owner.set_default_owner();
            pad.pad_owner.default.update_node(pad);
        }
    }
}