prototty_event_routine 0.29.0

Pseudo-synchronous composable event-based state machines for prototty apps
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

use crate::*;
use prototty_input::keys;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CommonEvent {
    Input(Input),
    Frame(Duration),
}

impl From<Input> for CommonEvent {
    fn from(input: Input) -> Self {
        CommonEvent::Input(input)
    }
}

impl From<Duration> for CommonEvent {
    fn from(duration: Duration) -> Self {
        CommonEvent::Frame(duration)
    }
}

pub struct ConvertInputToCommonEvent<T>(pub(crate) T);

impl<T> EventRoutine for ConvertInputToCommonEvent<T>
where
    T: EventRoutine<Event = Input>,
{
    type Return = T::Return;
    type Data = T::Data;
    type View = T::View;
    type Event = CommonEvent;

    fn handle<EP>(self, data: &mut Self::Data, view: &Self::View, event_or_peek: EP) -> Handled<Self::Return, Self>
    where
        EP: EventOrPeek<Event = Self::Event>,
    {
        event_or_peek.with(
            self,
            |s, event| match event {
                CommonEvent::Input(input) => s.0.handle(data, view, Event::new(input)).map_continue(Self),
                CommonEvent::Frame(_) => Handled::Continue(s),
            },
            Handled::Continue,
        )
    }

    fn view<G, C>(&self, data: &Self::Data, view: &mut Self::View, context: ViewContext<C>, frame: &mut G)
    where
        G: Frame,
        C: ColModify,
    {
        self.0.view(data, view, context, frame)
    }
}

pub struct ReturnOnExit<T, F> {
    pub(crate) t: T,
    pub(crate) f: F,
}

impl<T, F> EventRoutine for ReturnOnExit<T, F>
where
    T: EventRoutine<Event = CommonEvent>,
    F: FnOnce(&mut T::Data) -> T::Return,
{
    type Return = T::Return;
    type Data = T::Data;
    type View = T::View;
    type Event = CommonEvent;

    fn handle<EP>(self, data: &mut Self::Data, view: &Self::View, event_or_peek: EP) -> Handled<Self::Return, Self>
    where
        EP: EventOrPeek<Event = Self::Event>,
    {
        event_or_peek.with(
            (self, data),
            |(s, data), event| {
                let Self { t, f } = s;
                if event == CommonEvent::Input(Input::Keyboard(keys::ETX)) {
                    Handled::Return(f(data))
                } else {
                    t.handle(data, view, Event::new(event)).map_continue(|t| Self { t, f })
                }
            },
            |(s, data)| {
                let Self { t, f } = s;
                t.handle(data, view, Peek::new()).map_continue(|t| Self { t, f })
            },
        )
    }

    fn view<G, C>(&self, data: &Self::Data, view: &mut Self::View, context: ViewContext<C>, frame: &mut G)
    where
        G: Frame,
        C: ColModify,
    {
        self.t.view(data, view, context, frame)
    }
}