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
126
127
128
129
130
131

//! TODO Documentation

use std::{cell::Cell, ptr::NonNull, rc::Rc};

use wlroots_sys::{wlr_input_device, wlr_pointer};

use {input::{self, InputState},
     utils::{self, Handleable, HandleErr, HandleResult}};
pub use manager::pointer_handler::*;
pub use events::pointer_events as event;

pub type Handle = utils::Handle<NonNull<wlr_input_device>, wlr_pointer, Pointer>;

#[derive(Debug)]
pub struct Pointer {
    /// The structure that ensures weak handles to this structure are still alive.
    ///
    /// They contain weak handles, and will safely not use dead memory when this
    /// is freed by wlroots.
    ///
    /// If this is `None`, then this is from an upgraded `pointer::Handle`, and
    /// the operations are **unchecked**.
    /// This is means safe operations might fail, but only if you use the unsafe
    /// marked function `upgrade` on a `pointer::Handle`.
    liveliness: Rc<Cell<bool>>,
    /// The device that refers to this pointer.
    device: input::Device,
    /// The underlying pointer data.
    pointer: NonNull<wlr_pointer>
}

impl Pointer {
    /// Tries to convert an input device to a Pointer
    ///
    /// Returns none if it is of a different input variant.
    ///
    /// # Safety
    /// This creates a totally new Pointer (e.g with its own reference count)
    /// so only do this once per `wlr_input_device`!
    pub(crate) unsafe fn new_from_input_device(device: *mut wlr_input_device) -> Option<Self> {
        use wlroots_sys::wlr_input_device_type::*;
        match (*device).type_ {
            WLR_INPUT_DEVICE_POINTER => {
                let pointer = NonNull::new((*device).__bindgen_anon_1.pointer)
                    .expect("Pointer pointer was null");
                let liveliness = Rc::new(Cell::new(false));
                let handle = Rc::downgrade(&liveliness);
                let state = Box::new(InputState { handle,
                                                  device: input::Device::from_ptr(device) });
                (*pointer.as_ptr()).data = Box::into_raw(state) as *mut _;
                Some(Pointer { liveliness,
                               device: input::Device::from_ptr(device),
                               pointer })
            }
            _ => None
        }
    }

    /// Gets the wlr_input_device associated with this Pointer.
    pub fn input_device(&self) -> &input::Device {
        &self.device
    }

    /// Gets the wlr_pointer associated with this Pointer.
    #[allow(dead_code)]
    pub(crate) unsafe fn as_ptr(&self) -> *mut wlr_pointer {
        self.pointer.as_ptr()
    }
}

impl Drop for Pointer {
    fn drop(&mut self) {
        if Rc::strong_count(&self.liveliness) == 1 {
            wlr_log!(WLR_DEBUG, "Dropped Pointer {:p}", self.pointer);
            unsafe {
                let _ = Box::from_raw((*self.pointer.as_ptr()).data as *mut InputState);
            }
            let weak_count = Rc::weak_count(&self.liveliness);
            if weak_count > 0 {
                wlr_log!(WLR_DEBUG,
                         "Still {} weak pointers to Pointer {:p}",
                         weak_count,
                         self.pointer);
            }
        }
    }
}

impl Handleable<NonNull<wlr_input_device>, wlr_pointer> for Pointer {
    #[doc(hidden)]
    unsafe fn from_ptr(pointer: *mut wlr_pointer) -> Option<Self> {
        let pointer = NonNull::new(pointer)?;
        let data = Box::from_raw((*pointer.as_ptr()).data as *mut InputState);
        let handle = data.handle.clone();
        let device = data.device.clone();
        (*pointer.as_ptr()).data = Box::into_raw(data) as *mut _;
        Some(Pointer { liveliness: handle.upgrade().unwrap(),
                       device,
                       pointer })
    }

    #[doc(hidden)]
    unsafe fn as_ptr(&self) -> *mut wlr_pointer {
        self.pointer.as_ptr()
    }

    #[doc(hidden)]
    unsafe fn from_handle(handle: &Handle) -> HandleResult<Self> {
        let liveliness = handle.handle
            .upgrade()
            .ok_or(HandleErr::AlreadyDropped)?;
        let device = handle.data.ok_or(HandleErr::AlreadyDropped)?;
        Ok(Pointer { liveliness,
                     // NOTE Rationale for cloning:
                     // If we already dropped we don't reach this point.
                     device: input::Device { device },
                     pointer: handle.as_non_null()
        })
    }

    fn weak_reference(&self) -> Handle {
        Handle { ptr: self.pointer,
                 handle: Rc::downgrade(&self.liveliness),
                 // NOTE Rationale for cloning:
                 // Since we have a strong reference already,
                 // the input must still be alive.
                 data: unsafe { Some(self.device.as_non_null()) },
                 _marker: std::marker::PhantomData
        }
    }
}