cube-tui 0.1.9

Terminal UI timer and session manager for speedcubing, with optional web dashboard and BLE (GAN) timer support.
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

use crate::model::Model;
use crate::model::screen::{DetailsReturn, Screen};
use crate::widgets::history::{Modifier, Time};

impl Model {
    pub const fn show_details(&self) -> bool {
        self.screen.show_details()
    }

    pub fn open_details(&mut self) {
        let modifier_index = match self.history().selected_time().map(Time::modifier) {
            Some(Modifier::DNF) => 1,
            _ => 0,
        };
        self.screen = Screen::Details {
            modifier_index,
            return_to: DetailsReturn::Main,
        };
    }

    pub const fn close_current_screen(&mut self) {
        let new_screen = match &self.screen {
            Screen::Details { return_to, .. } => match return_to {
                DetailsReturn::Main => Screen::Main,
                DetailsReturn::MeanDetail {
                    row,
                    col,
                    selected_index,
                    from_stats_column,
                } => Screen::MeanDetail {
                    row: *row,
                    col: *col,
                    selected_index: *selected_index,
                    from_stats_column: *from_stats_column,
                },
            },
            Screen::Main | Screen::DetailedStats { .. } | Screen::ConfirmDeleteSession { .. } => {
                Screen::Main
            }
            Screen::MeanDetail {
                row,
                col,
                from_stats_column,
                ..
            } => {
                if *from_stats_column {
                    Screen::Main
                } else {
                    Screen::DetailedStats {
                        row: *row,
                        col: *col,
                    }
                }
            }
        };
        self.screen = new_screen;
    }

    pub fn next_details_modifier(&mut self) {
        if let Screen::Details { modifier_index, .. } = &mut self.screen {
            *modifier_index = (*modifier_index + 1).min(1);
        }
    }

    pub const fn prev_details_modifier(&mut self) {
        if let Screen::Details { modifier_index, .. } = &mut self.screen {
            *modifier_index = modifier_index.saturating_sub(1);
        }
    }

    pub const fn selected_details_modifier_index(&self) -> usize {
        if let Screen::Details { modifier_index, .. } = &self.screen {
            *modifier_index
        } else {
            0
        }
    }

    pub const fn selected_details_modifier(&self) -> Modifier {
        if let Screen::Details { modifier_index, .. } = &self.screen {
            if *modifier_index == 0 {
                Modifier::PlusTwo
            } else {
                Modifier::DNF
            }
        } else {
            Modifier::PlusTwo
        }
    }

    pub fn details_nav_prev(&mut self) {
        self.history_mut().select_previous();
        self.sync_details_modifier();
    }

    pub fn details_nav_next(&mut self) {
        self.history_mut().select_next();
        self.sync_details_modifier();
    }

    fn sync_details_modifier(&mut self) {
        let new_index = match self.history().selected_time().map(Time::modifier) {
            Some(Modifier::DNF) => 1,
            _ => 0,
        };
        if let Screen::Details { modifier_index, .. } = &mut self.screen {
            *modifier_index = new_index;
        }
    }
}