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

use embedded_graphics::primitives::Rectangle;

/// Redraw classes used by the compatibility [`crate::UiApp`] layer.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AppRedraw {
    /// No redraw is needed.
    None,
    /// A stack transition is active.
    StackMotion,
    /// An interactive region changed.
    Interactive,
    /// The full frame should be redrawn.
    Full,
}

impl AppRedraw {
    /// Merges two redraw requests.
    pub const fn merge(self, other: Self) -> Self {
        match (self, other) {
            (Self::Full, _) | (_, Self::Full) => Self::Full,
            (Self::StackMotion, _) | (_, Self::StackMotion) => Self::StackMotion,
            (Self::Interactive, _) | (_, Self::Interactive) => Self::Interactive,
            _ => Self::None,
        }
    }
}

/// Navigation action requested by the compatibility delegate API.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AppNavigation<ViewId> {
    /// Push a new view.
    Push(ViewId),
    /// Pop the current view.
    Pop,
}

/// Delegate response returned by compatibility views.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ViewResponse<ViewId> {
    /// Redraw request for the frame.
    pub redraw: AppRedraw,
    /// Optional navigation command.
    pub navigation: Option<AppNavigation<ViewId>>,
    /// Whether the interaction was captured.
    pub captured: bool,
}

impl<ViewId> ViewResponse<ViewId> {
    /// Returns a no-op response.
    pub const fn none() -> Self {
        Self {
            redraw: AppRedraw::None,
            navigation: None,
            captured: false,
        }
    }

    /// Creates a redraw-only response.
    pub const fn redraw(redraw: AppRedraw) -> Self {
        Self {
            redraw,
            navigation: None,
            captured: false,
        }
    }

    /// Creates a push-navigation response.
    pub fn push(view: ViewId) -> Self {
        Self {
            redraw: AppRedraw::None,
            navigation: Some(AppNavigation::Push(view)),
            captured: true,
        }
    }

    /// Creates a pop-navigation response.
    pub const fn pop() -> Self {
        Self {
            redraw: AppRedraw::None,
            navigation: Some(AppNavigation::Pop),
            captured: true,
        }
    }

    /// Merges in an extra redraw request.
    pub fn with_redraw(mut self, redraw: AppRedraw) -> Self {
        self.redraw = self.redraw.merge(redraw);
        self
    }

    /// Sets whether the interaction was captured.
    pub const fn with_capture(mut self, captured: bool) -> Self {
        self.captured = captured;
        self
    }
}

/// Result of handling one touch event through the compatibility layer.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AppTouchResult {
    /// Redraw request for the frame.
    pub redraw: AppRedraw,
    /// Whether the touch was captured.
    pub captured: bool,
}

/// Geometry used during stack-motion presentation.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct StackMotion {
    /// Header region.
    pub header: Rectangle,
    /// Main body region.
    pub body: Rectangle,
    /// Overlay region for the entering or leaving view.
    pub overlay: Rectangle,
}