workshop 1.0.19

A tool for presenting programming workshops
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

pub mod lesson;
pub use lesson::Lesson;
pub mod lessons;
pub use lessons::Lessons;
pub mod license;
pub use license::License;
pub mod log;
pub use log::Log;
pub mod programming;
pub use programming::Programming;
pub mod set_default;
pub use set_default::SetDefault;
pub mod spoken;
pub use spoken::Spoken;
pub mod welcome;
pub use welcome::Welcome;
pub mod workshops;
pub use workshops::Workshops;

use crate::{ui::tui, Error, Status};
use crossterm::event;
use ratatui::{buffer::Buffer, layout::Rect};
use std::{
    fmt,
    sync::{Arc, Mutex},
};
use tokio::sync::mpsc::Sender;

/// The screens
#[repr(u8)]
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
pub enum Screens {
    #[default]
    Welcome,
    Workshops,
    Log,
    License,
    Spoken,
    Programming,
    SetDefault,
    Lessons,
    Lesson,
}

impl Screens {
    pub fn iter() -> impl Iterator<Item = Screens> {
        (0..=8).map(Screens::from)
    }
}

impl fmt::Display for Screens {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Screens::Welcome => write!(f, "Welcome"),
            Screens::Workshops => write!(f, "Workshops"),
            Screens::Log => write!(f, "Log"),
            Screens::License => write!(f, "License"),
            Screens::Spoken => write!(f, "Spoken"),
            Screens::Programming => write!(f, "Programming"),
            Screens::SetDefault => write!(f, "Set Default"),
            Screens::Lessons => write!(f, "Lessons"),
            Screens::Lesson => write!(f, "Lesson"),
        }
    }
}

impl From<Screens> for u8 {
    fn from(screen: Screens) -> Self {
        screen as u8
    }
}

impl From<u8> for Screens {
    fn from(value: u8) -> Self {
        match value {
            0 => Screens::Welcome,
            1 => Screens::Workshops,
            2 => Screens::Log,
            3 => Screens::License,
            4 => Screens::Spoken,
            5 => Screens::Programming,
            6 => Screens::SetDefault,
            7 => Screens::Lessons,
            8 => Screens::Lesson,
            _ => panic!("Invalid screen value"),
        }
    }
}

/// The possible events to handle
#[derive(Clone, Debug)]
pub enum Event {
    Input(event::Event),
    Ui(Option<Screens>, tui::Event),
}

impl From<event::Event> for Event {
    fn from(event: event::Event) -> Self {
        Event::Input(event)
    }
}

impl From<(Option<Screens>, tui::Event)> for Event {
    fn from(tuple: (Option<Screens>, tui::Event)) -> Self {
        Event::Ui(tuple.0, tuple.1)
    }
}

impl From<tui::Evt> for Event {
    fn from(evt: tui::Evt) -> Self {
        Event::Ui(evt.0, *evt.1)
    }
}

/// The State trait
#[async_trait::async_trait]
pub trait Screen: Send + Sync {
    /// Handle an event
    async fn handle_event(
        &mut self,
        event: Event,
        to_ui: Sender<Event>,
        status: Arc<Mutex<Status>>,
    ) -> Result<(), Error>;

    /// Render the screen
    fn render_screen(&mut self, area: Rect, buf: &mut Buffer) -> Result<(), Error>;
}