wlroots 0.4.0

Wayland compositor framework
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

//! Handler for tablet tools

use libc;
use wlroots_sys::wlr_input_device;
use wayland_sys::server::WAYLAND_SERVER_HANDLE;

use {compositor,
     input::tablet_tool::{self, TabletTool},
     utils::Handleable};

#[allow(unused_variables)]
pub trait Handler {
    /// Callback that is triggered when an axis event fires
    fn on_axis(&mut self,
               compositor_handle: compositor::Handle,
               tablet_tool_handle: tablet_tool::Handle,
               event: &tablet_tool::event::Axis) {}

    /// Callback that is triggered when a table tool is brought close to the
    /// input source.
    fn on_proximity(&mut self,
                    compositor_handle: compositor::Handle,
                    tablet_tool_handle: tablet_tool::Handle,
                    event: &tablet_tool::event::Proximity) {}

    /// Callback that is triggered when a table tool's tip touches the input
    /// source.
    fn on_tip(&mut self,
              compositor_handle: compositor::Handle,
              tablet_tool_handle: tablet_tool::Handle,
              event: &tablet_tool::event::Tip) {}

    /// Callback that is triggered when a button is pressed on the tablet tool.
    fn on_button(&mut self,
                 compositor_handle: compositor::Handle,
                 tablet_tool_handle: tablet_tool::Handle,
                 event: &tablet_tool::event::Button) {}

    /// Callback that is triggered when a tablet tool is destroyed.
    fn destroyed(&mut self,
                 compositor_handle: compositor::Handle,
                 tablet_tool_handle: tablet_tool::Handle) {}
}

wayland_listener!(pub(crate) TabletToolWrapper, (TabletTool, Box<Handler>), [
    on_destroy_listener => on_destroy_notify: |this: &mut TabletToolWrapper, data: *mut libc::c_void,|
    unsafe {
        let input_device_ptr = data as *mut wlr_input_device;
        {
            let (ref mut tool, ref mut tablet_tool_handler) = this.data;
            let compositor = match compositor::handle() {
                Some(handle) => handle,
                None => return
            };
            tablet_tool_handler.destroyed(compositor, tool.weak_reference());
        }
        ffi_dispatch!(WAYLAND_SERVER_HANDLE,
                      wl_list_remove,
                      &mut (*this.on_destroy_listener()).link as *mut _ as _);
        ffi_dispatch!(WAYLAND_SERVER_HANDLE,
                      wl_list_remove,
                      &mut (*this.axis_listener()).link as *mut _ as _);
        ffi_dispatch!(WAYLAND_SERVER_HANDLE,
                      wl_list_remove,
                      &mut (*this.proximity_listener()).link as *mut _ as _);
        ffi_dispatch!(WAYLAND_SERVER_HANDLE,
                      wl_list_remove,
                      &mut (*this.tip_listener()).link as *mut _ as _);
        ffi_dispatch!(WAYLAND_SERVER_HANDLE,
                      wl_list_remove,
                      &mut (*this.button_listener()).link as *mut _ as _);
        Box::from_raw((*input_device_ptr).data as *mut TabletToolWrapper);
    };
    axis_listener => axis_notify: |this: &mut TabletToolWrapper, data: *mut libc::c_void,| unsafe {
        let (ref tool, ref mut handler) = this.data;
        let event = tablet_tool::event::Axis::from_ptr(data as *mut _);
        let compositor = match compositor::handle() {
            Some(handle) => handle,
            None => return
        };

        handler.on_axis(compositor,
                        tool.weak_reference(),
                        &event);
    };
    proximity_listener => proximity_notify: |this: &mut TabletToolWrapper,
    data: *mut libc::c_void,|
    unsafe {
        let (ref tool, ref mut handler) = this.data;
        let event = tablet_tool::event::Proximity::from_ptr(data as *mut _);
        let compositor = match compositor::handle() {
            Some(handle) => handle,
            None => return
        };

        handler.on_proximity(compositor,
                             tool.weak_reference(),
                             &event);
    };
    tip_listener => tip_notify: |this: &mut TabletToolWrapper, data: *mut libc::c_void,| unsafe {
        let (ref tool, ref mut handler) = this.data;
        let event = tablet_tool::event::Tip::from_ptr(data as *mut _);
        let compositor = match compositor::handle() {
            Some(handle) => handle,
            None => return
        };

        handler.on_tip(compositor,
                       tool.weak_reference(),
                       &event);
    };
    button_listener => button_notify: |this: &mut TabletToolWrapper, data: *mut libc::c_void,|
    unsafe {
        let (ref tool, ref mut handler) = this.data;
        let event = tablet_tool::event::Button::from_ptr(data as *mut _);
        let compositor = match compositor::handle() {
            Some(handle) => handle,
            None => return
        };

        handler.on_button(compositor,
                          tool.weak_reference(),
                          &event);
    };
]);