buttons 0.8.0

A simple API for storing and querying input state.
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
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::Event;
use std::ops::Add;

/// Represents an active touch on the touch device.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Touch<Id, Coord>
where
    Id: PartialEq,
    Coord: Copy + Default + Add<Output = Coord>,
{
    pub id: Id,
    pub position: [Coord; 2],
    pub tapped: bool,
    pub released: bool,
}

/// The phase of a touch.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TouchPhase {
    Start,
    End,
    Cancel,
    Move,
}

/// A trait for objects that can represent the state of a touch device.
pub trait TouchInterface {
    /// A type that can uniquely represent a touch.
    type TouchId: PartialEq;

    /// The numeric type used for touch coordinates.
    type Coord: Copy + Default + Add<Output = Self::Coord>;

    /// Returns a reference to the first registered touch, if any.
    fn first_touch(&self) -> Option<&Touch<Self::TouchId, Self::Coord>>;

    /// Returns a touch by its `id`, if it exists.
    fn touch<I: AsRef<Self::TouchId>>(&self, id: I) -> Option<&Touch<Self::TouchId, Self::Coord>>;

    /// Returns an iterator over all active touches.
    ///
    /// (This includes touches that have been released this frame.)
    fn touches(&self) -> impl Iterator<Item = &Touch<Self::TouchId, Self::Coord>>;

    /// Register a touch event.
    fn touch_event<I, P>(&mut self, id: I, position: [Self::Coord; 2], phase: P) -> &mut Self
    where
        I: Into<Self::TouchId>,
        P: Into<TouchPhase>;

    /// Clears the tapped/released state of active touches. Should be called at the end of each frame.
    fn clear_taps(&mut self) -> &mut Self;

    /// Convenience method for handling events. The type of event, `E`, will
    /// vary depending on the windowing library being used.
    fn handle_event<E: Event<Self>>(&mut self, event: &E) -> &mut Self {
        event.handle(self);
        self
    }
}

/// A structure representing the current state of touches on a touch device.
#[derive(Debug, Clone)]
pub struct Touchpad<Id, Coord>
where
    Id: PartialEq,
    Coord: Copy + Default + Add<Output = Coord>,
{
    touches: Vec<Touch<Id, Coord>>,
}

impl<Id, Coord> Default for Touchpad<Id, Coord>
where
    Id: PartialEq,
    Coord: Copy + Default + Add<Output = Coord>,
{
    fn default() -> Self {
        Self::new()
    }
}

impl<Id, Coord> Touchpad<Id, Coord>
where
    Id: PartialEq,
    Coord: Copy + Default + Add<Output = Coord>,
{
    pub fn new() -> Self {
        Touchpad {
            touches: Vec::with_capacity(4),
        }
    }
}

impl<Id, C> TouchInterface for Touchpad<Id, C>
where
    Id: PartialEq,
    C: Copy + Default + Add<Output = C>,
{
    type TouchId = Id;
    type Coord = C;

    fn first_touch(&self) -> Option<&Touch<Self::TouchId, Self::Coord>> {
        self.touches.first()
    }

    fn touch<I: AsRef<Self::TouchId>>(&self, id: I) -> Option<&Touch<Self::TouchId, Self::Coord>> {
        self.touches.iter().find(|t| &t.id == id.as_ref())
    }

    fn touches(&self) -> impl Iterator<Item = &Touch<Self::TouchId, Self::Coord>> {
        self.touches.iter()
    }

    fn touch_event<I, P>(&mut self, id: I, position: [Self::Coord; 2], phase: P) -> &mut Self
    where
        I: Into<Self::TouchId>,
        P: Into<TouchPhase>,
    {
        let id = id.into();
        let existing_touch = self.touches.iter_mut().find(|t| t.id == id);
        let existing_touch = match existing_touch {
            Some(t) => t,
            None => {
                self.touches.push(Touch {
                    id,
                    position,
                    tapped: false,
                    released: false,
                });
                self.touches.last_mut().unwrap()
            }
        };

        match phase.into() {
            TouchPhase::Start => existing_touch.tapped = true,
            TouchPhase::Cancel | TouchPhase::End => existing_touch.released = true,
            _ => (),
        }

        existing_touch.position = position;
        self
    }

    fn clear_taps(&mut self) -> &mut Self {
        for touch in &mut self.touches {
            touch.tapped = false;
        }
        self.touches.retain(|t| !t.released);
        self
    }
}