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

use crate::{common_event::CommonEvent, Event, EventRoutine, Handled};
use prototty_app::{App, ColModify, ControlFlow, Duration, Frame, Input, ViewContext};

pub struct EventRoutineAppOneShotIgnoreReturn<ER>
where
    ER: EventRoutine,
{
    event_routine: Option<ER>,
    data: ER::Data,
    view: ER::View,
}

impl<ER> EventRoutineAppOneShotIgnoreReturn<ER>
where
    ER: EventRoutine,
{
    pub fn new(event_routine: ER, data: ER::Data, view: ER::View) -> Self {
        Self {
            event_routine: Some(event_routine),
            data,
            view,
        }
    }
}

impl<ER> App for EventRoutineAppOneShotIgnoreReturn<ER>
where
    ER: EventRoutine<Event = CommonEvent>,
{
    fn on_input(&mut self, input: Input) -> Option<ControlFlow> {
        self.event_routine = if let Some(event_routine) = self.event_routine.take() {
            match event_routine.handle(&mut self.data, &self.view, Event::new(input.into())) {
                Handled::Continue(event_routine) => Some(event_routine),
                Handled::Return(_) => return Some(ControlFlow::Exit),
            }
        } else {
            log::warn!("on_input: app has exited");
            None
        };
        None
    }
    fn on_frame<F, C>(
        &mut self,
        since_last_frame: Duration,
        view_context: ViewContext<C>,
        frame: &mut F,
    ) -> Option<ControlFlow>
    where
        F: Frame,
        C: ColModify,
    {
        self.event_routine = if let Some(event_routine) = self.event_routine.take() {
            match event_routine.handle(&mut self.data, &self.view, Event::new(since_last_frame.into())) {
                Handled::Continue(event_routine) => {
                    event_routine.view(&self.data, &mut self.view, view_context, frame);
                    Some(event_routine)
                }
                Handled::Return(_) => return Some(ControlFlow::Exit),
            }
        } else {
            log::warn!("on_frame: app has exited");
            None
        };
        None
    }
}