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

// Take a look at the license at the top of the repository in the LICENSE file.

use glib::translate::*;

/// Used for touch events.
/// `type` field will be one of [`EventType::TouchBegin`][crate::EventType::TouchBegin], [`EventType::TouchUpdate`][crate::EventType::TouchUpdate],
/// [`EventType::TouchEnd`][crate::EventType::TouchEnd] or [`EventType::TouchCancel`][crate::EventType::TouchCancel].
///
/// Touch events are grouped into sequences by means of the `sequence`
/// field, which can also be obtained with `gdk_event_get_event_sequence()`.
/// Each sequence begins with a [`EventType::TouchBegin`][crate::EventType::TouchBegin] event, followed by
/// any number of [`EventType::TouchUpdate`][crate::EventType::TouchUpdate] events, and ends with a [`EventType::TouchEnd`][crate::EventType::TouchEnd]
/// (or [`EventType::TouchCancel`][crate::EventType::TouchCancel]) event. With multitouch devices, there may be
/// several active sequences at the same time.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EventTouch(crate::Event);

event_wrapper!(EventTouch, GdkEventTouch);
event_subtype!(
    EventTouch,
    ffi::GDK_TOUCH_BEGIN | ffi::GDK_TOUCH_UPDATE | ffi::GDK_TOUCH_END | ffi::GDK_TOUCH_CANCEL
);

impl EventTouch {
    #[doc(alias = "get_time")]
    pub fn time(&self) -> u32 {
        self.as_ref().time
    }

    #[doc(alias = "get_position")]
    pub fn position(&self) -> (f64, f64) {
        let x = self.as_ref().x;
        let y = self.as_ref().y;
        (x, y)
    }

    #[doc(alias = "get_state")]
    pub fn state(&self) -> crate::ModifierType {
        unsafe { from_glib(self.as_ref().state) }
    }

    pub fn is_emulating_pointer(&self) -> bool {
        unsafe { from_glib(self.as_ref().emulating_pointer) }
    }

    #[doc(alias = "get_device")]
    pub fn device(&self) -> Option<crate::Device> {
        unsafe { from_glib_none(self.as_ref().device) }
    }

    #[doc(alias = "get_axes")]
    pub fn axes(&self) -> Option<(f64, f64)> {
        let axes = self.as_ref().axes;

        if axes.is_null() {
            None
        } else {
            unsafe { Some((*axes, *axes.offset(1))) }
        }
    }

    #[doc(alias = "get_root")]
    pub fn root(&self) -> (f64, f64) {
        let x_root = self.as_ref().x_root;
        let y_root = self.as_ref().y_root;
        (x_root, y_root)
    }

    #[doc(alias = "get_event_sequence")]
    pub fn event_sequence(&self) -> Option<crate::EventSequence> {
        unsafe { from_glib_none(self.as_ref().sequence) }
    }
}