faststep 0.1.0

UIKit-inspired embedded UI framework built on embedded-graphics
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

use embedded_graphics::primitives::Rectangle;

use crate::{Button, TouchEvent, TouchPhase};

/// Result returned by shared multi-button touch tracking.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ButtonTouchResponse<K> {
    /// Activated button key, if any.
    pub action: Option<K>,
    /// Whether the touch sequence was captured.
    pub captured: bool,
    /// Whether visual state changed and needs redraw.
    pub redraw: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct ActiveButton<K> {
    key: K,
    frame: Rectangle,
    highlighted: bool,
}

/// Shared touch tracker for a set of buttons.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ButtonTouchState<K> {
    active: Option<ActiveButton<K>>,
}

impl<K: Copy + Eq> ButtonTouchState<K> {
    /// Creates an empty touch state.
    pub const fn new() -> Self {
        Self { active: None }
    }

    /// Clears the active button, if any.
    pub fn clear(&mut self) {
        self.active = None;
    }

    /// Returns whether the supplied button is currently highlighted.
    pub fn is_highlighted(&self, button: &Button<'_, K>) -> bool {
        matches!(
            self.active,
            Some(active)
                if active.highlighted
                    && active.key == button.spec.key
                    && active.frame == button.frame
        )
    }

    /// Applies a touch sample to a button slice.
    pub fn handle_touch<'a>(
        &mut self,
        touch: TouchEvent,
        buttons: &[Button<'a, K>],
    ) -> ButtonTouchResponse<K> {
        let was_active = self.active;
        match touch.phase {
            TouchPhase::Start => {
                self.active = buttons.iter().find_map(|button| {
                    touch.within(button.frame).then_some(ActiveButton {
                        key: button.spec.key,
                        frame: button.frame,
                        highlighted: true,
                    })
                });
                ButtonTouchResponse {
                    action: None,
                    captured: self.active.is_some(),
                    redraw: was_active != self.active,
                }
            }
            TouchPhase::Move => self.move_touch(touch),
            TouchPhase::End => self.finish_touch(touch),
            TouchPhase::Cancel => self.cancel_touch(),
        }
    }

    fn move_touch(&mut self, touch: TouchEvent) -> ButtonTouchResponse<K> {
        let Some(mut active) = self.active else {
            return ButtonTouchResponse {
                action: None,
                captured: false,
                redraw: false,
            };
        };
        let highlighted = touch.within(active.frame);
        let redraw = highlighted != active.highlighted;
        active.highlighted = highlighted;
        self.active = Some(active);
        ButtonTouchResponse {
            action: None,
            captured: true,
            redraw,
        }
    }

    fn finish_touch(&mut self, touch: TouchEvent) -> ButtonTouchResponse<K> {
        let Some(active) = self.active.take() else {
            return ButtonTouchResponse {
                action: None,
                captured: false,
                redraw: false,
            };
        };
        ButtonTouchResponse {
            action: (active.highlighted && touch.within(active.frame)).then_some(active.key),
            captured: true,
            redraw: active.highlighted,
        }
    }

    fn cancel_touch(&mut self) -> ButtonTouchResponse<K> {
        let Some(active) = self.active.take() else {
            return ButtonTouchResponse {
                action: None,
                captured: false,
                redraw: false,
            };
        };
        ButtonTouchResponse {
            action: None,
            captured: true,
            redraw: active.highlighted,
        }
    }
}