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

use std::sync::{Arc, Mutex};

use {TouchPhase, WindowEvent};

use super::{DeviceId, WindowId};
use super::event_loop::EventsLoopSink;
use super::window::WindowStore;

use sctk::reexports::client::Proxy;
use sctk::reexports::client::protocol::wl_touch::{Event as TouchEvent, WlTouch};
use sctk::reexports::client::protocol::wl_seat;
use sctk::reexports::client::protocol::wl_seat::RequestsTrait as SeatRequests;

struct TouchPoint {
    wid: WindowId,
    location: (f64, f64),
    id: i32,
}

pub(crate) fn implement_touch(
    seat: &Proxy<wl_seat::WlSeat>,
    sink: Arc<Mutex<EventsLoopSink>>,
    store: Arc<Mutex<WindowStore>>,
) -> Proxy<WlTouch> {
    let mut pending_ids = Vec::new();
    seat.get_touch(|touch| {
        touch.implement(move |evt, _| {
            let mut sink = sink.lock().unwrap();
            let store = store.lock().unwrap();
            match evt {
                TouchEvent::Down {
                    surface, id, x, y, ..
                } => {
                    let wid = store.find_wid(&surface);
                    if let Some(wid) = wid {
                        sink.send_event(
                            WindowEvent::Touch(::Touch {
                                device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
                                phase: TouchPhase::Started,
                                location: (x, y).into(),
                                id: id as u64,
                            }),
                            wid,
                        );
                        pending_ids.push(TouchPoint {
                            wid: wid,
                            location: (x, y),
                            id: id,
                        });
                    }
                }
                TouchEvent::Up { id, .. } => {
                    let idx = pending_ids.iter().position(|p| p.id == id);
                    if let Some(idx) = idx {
                        let pt = pending_ids.remove(idx);
                        sink.send_event(
                            WindowEvent::Touch(::Touch {
                                device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
                                phase: TouchPhase::Ended,
                                location: pt.location.into(),
                                id: id as u64,
                            }),
                            pt.wid,
                        );
                    }
                }
                TouchEvent::Motion { id, x, y, .. } => {
                    let pt = pending_ids.iter_mut().find(|p| p.id == id);
                    if let Some(pt) = pt {
                        pt.location = (x, y);
                        sink.send_event(
                            WindowEvent::Touch(::Touch {
                                device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
                                phase: TouchPhase::Moved,
                                location: (x, y).into(),
                                id: id as u64,
                            }),
                            pt.wid,
                        );
                    }
                }
                TouchEvent::Frame => (),
                TouchEvent::Cancel => for pt in pending_ids.drain(..) {
                    sink.send_event(
                        WindowEvent::Touch(::Touch {
                            device_id: ::DeviceId(::platform::DeviceId::Wayland(DeviceId)),
                            phase: TouchPhase::Cancelled,
                            location: pt.location.into(),
                            id: pt.id as u64,
                        }),
                        pt.wid,
                    );
                },
            }
        }, ())
    }).unwrap()
}