winit 0.16.2

Cross-platform window creation library.
Documentation 
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

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::{NewProxy, Proxy};
use sctk::reexports::client::protocol::wl_touch::{Event as TouchEvent, WlTouch};

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

pub(crate) fn implement_touch(
    touch: NewProxy<WlTouch>,
    sink: Arc<Mutex<EventsLoopSink>>,
    store: Arc<Mutex<WindowStore>>,
) -> Proxy<WlTouch> {
    let mut pending_ids = Vec::new();
    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,
                );
            },
        }
    })
}