Menu.cpp

Go to the documentation of this file.

#include "../include/Menu.hpp"

using namespace std;

const double LOOPTIME = 0.01;

const int NUM_FONTS = 4;

/* =========================================================
CONSTRUCTOR
========================================================= */

Menu::Menu(bool testing){ 
    srand(static_cast<unsigned int>(chrono::high_resolution_clock::now().time_since_epoch().count()));
    _display = Display();
    _run = true;
    _testing = testing;
    _menuFormats = { Display::BOLD_WHITE, Display::BOLD_WHITE, Display::BOLD_WHITE, Display::BOLD_WHITE, Display::BOLD_WHITE };
    _settingsFormats = { Display::BOLD_WHITE, Display::BOLD_WHITE, Display::BOLD_WHITE, Display::BOLD_WHITE};

    _notiSetting = true;
    _fontSetting = 1;

    loadSettings();

    _display.setFont(_fontSetting);

    _display.clearScreen();
    mainMenu(0);
}

/* =========================================================
HELPER FUNCTIONS
========================================================= */

void Menu::printArt(vector<string> art, string formatting){
    _display.setFormat(formatting);

    for (string line : art){
        cout << line << endl;
    }

    _display.clearFormat();
}

void Menu::credits(){
    _display.clearScreen();

    string lBuffer = "                         ";

    printArt(_logoArt, Display::BOLD_CYAN);

    _display.setFormat(Display::WHITE);
    cout << endl;
    for (string line : _credits){
        cout << lBuffer << line << endl;
    }
    _display.clearFormat();

    _display.setCursor(1,1);
    
    waitForInput();

    _display.clearScreen();
}

void Menu::loadSettings() {
    ifstream settingsFile("settings.txt");
    
    if (settingsFile.is_open()) {
        settingsFile >> _fontSetting;
        settingsFile >> _notiSetting;
        settingsFile.close();
    } else {
        // Default settings if the file doesn't exist
        _fontSetting = 1;
        _notiSetting = true;
    }
}

void Menu::saveSettings() {
    ofstream settingsFile("settings.txt");
    
    if (settingsFile.is_open()) {
        settingsFile << _fontSetting << endl;
        settingsFile << _notiSetting << endl;
        settingsFile.close();
    }
}

/* =========================================================
MAIN MENU SEQUENCE
========================================================= */

void Menu::mainMenu(int selected) {

    for (int i = 0; i < _menuFormats.size(); ++i) {
        if (i == selected) {
            _menuFormats.at(i) = Display::SELECTED;
        } else {
            _menuFormats.at(i) = Display::BOLD_WHITE;
        }
    }

    _display.setCursor(1,1);

    printArt(_menuArt, Display::BOLD_CYAN);

    printArt(_menuTimer, _menuFormats.at(0));

    printArt(_menuStopwatch, _menuFormats.at(1));

    printArt(_menuAlarm, _menuFormats.at(2));

    printArt(_menuSettings, _menuFormats.at(3));

    printArt(_menuQuit, _menuFormats.at(4));

    _display.setCursor(1,1);

    char in = getMenuInput(selected);

    if(_testing){ in = '1'; }
    // ENTER TIMER SEQUENCE
    if(in == '1'){
        timerSequence();
        _display.clearScreen();
    }

    if(_testing){ in = '2'; }
    // ENTER STOPWATCH SEQUENCE
    if(in == '2'){
        stopwatchSequence();
        _display.clearScreen();
    }

    if(_testing){ in = '3'; }
    // ENTER ALARM SEQUENCE
    if(in == '3'){
        alarmSequence();
        _display.clearScreen();
    }

    if(_testing){ in = '4'; }
    // ENTER SETTINGS SEQUENCE
    if(in == 's' || in == '4'){
        _display.clearScreen();
        settingsMenu(0);
        _display.clearScreen();
    }

    if(_testing){ in = '5'; }
    // QUIT PROGRAM
    if(in == 'q' || in == '5'){
        _display.clearScreen();
        return;
    }
    
    // Restart menu loop
    mainMenu(selected);
}

void Menu::settingsMenu(int selected) {

    for (int i = 0; i < _settingsFormats.size(); ++i) {
        if (i == selected) {
            _settingsFormats.at(i) = Display::SELECTED;
        } else {
            _settingsFormats.at(i) = Display::BOLD_WHITE;
        }
    }

    _display.setCursor(1,1);

    printArt(_settingsArt, Display::BOLD_CYAN);

    switch(_fontSetting){
        case 1:
            printArt(_settingsFont1, _settingsFormats.at(0));
            break;
        case 2:
            printArt(_settingsFont2, _settingsFormats.at(0));
            break;
        case 3:
            printArt(_settingsFont3, _settingsFormats.at(0));
            break;
        case 4:
            printArt(_settingsFont4, _settingsFormats.at(0));
            break;
    }

    if(_notiSetting){
        printArt(_settingsNotiOn, _settingsFormats.at(1));
    }
    else{
        printArt(_settingsNotiOff, _settingsFormats.at(1));
    }

    printArt(_settingsCredits, _settingsFormats.at(2));

    printArt(_settingsBack, _settingsFormats.at(3));

    _display.setCursor(1,1);
    
    char in = getSettingsInput(selected);

    if(_testing){ in = '1'; }
    if(in == '1'){
        //Rotate fonts
        if(_fontSetting < NUM_FONTS){
            _fontSetting++;
        }
        else{
            _fontSetting = 1;
        }
        saveSettings();
    }

    if(_testing){ in = '2'; }
    if(in == '2'){
        //Toggle notifications
        _notiSetting = !_notiSetting;
        saveSettings();
    }

    if(_testing){ in = '3'; }
    if(in == '3'){
        credits();
    }

    if(_testing){ in = '4'; }
    if(in == 'q' || in == '4' ){
        saveSettings();
        _display.setFont(_fontSetting);
        return;
    }
    
    //printArt(_settingsBlank, "");
    settingsMenu(selected);
}

void Menu::timerSequence(){
    _display.clearScreen();

    bool run = true;
    bool notified = false;

    Timer timer = createTimer(run);

    _display.clearScreen();

    while(run){
        // Display a message when the timer finishes
        if(timer.remainingMilliseconds() == 0) {
            _display.setSplash("TIMER FINISHED"); 
            if(_notiSetting && !notified){
                Notification noti("Tempo", "Your timer is finished!");
                notified = true;
            }
        }

        _display.tickTimer(timer);

        checkTimerInput(timer, run);

        wait(LOOPTIME);

        if(_testing){
            run = false;
        }
    }
}

void Menu::stopwatchSequence(){

    _display.clearScreen();

    Stopwatch stopwatch;

    bool run = true;

    _display.setSplash("PRESS 'S' TO START");

    _display.tickStopwatch(stopwatch);

    //_display.clearScreen();
    
    while(run){
        _display.tickStopwatch(stopwatch);

        checkStopwatchInput(stopwatch, run);

        wait(LOOPTIME);

        if(_testing){
            run = false;
        }
    }
}

void Menu::alarmSequence(){
    _display.clearScreen();

    bool run = true;
    bool notified = false;

    Alarm alarm = createAlarm(run);

    _display.clearScreen();

    while(run){
        // Display a message when the alarm finishes
        if(alarm.isDone()) {
            _display.setSplash("ALARM FINISHED"); 
            if(_notiSetting && !notified){
                Notification noti("Tempo", "Your alarm is finished!");
                notified = true;
            }
        }

        _display.tickAlarm(alarm);

        checkAlarmInput(alarm, run);

        wait(LOOPTIME);

        if(_testing){
            run = false;
        }
    }
}

Timer Menu::createTimer(bool& run){
    int h = 0;
    int m = 0;
    int s = 0;
    int countdownSeconds = 0;

    string input = "000000";

    string to_print = "00:00:00";

    _display.tickTimerSetup(to_print);
    
    int index = 5;
    
    while (true) {
        char ch; 
        if(_testing){
            ch = '1';
        }
        else if(_kbhit()){
            ch = _getch();
        }
        else{
            ch = 0;
        }

        if (ch == 13 && (h || m || s)) {
            break;
        } 
        else if (ch >= '0' && ch <= '9') {
            input = input.substr(1) + ch; 
        } 
        else if (ch == 8) { 
            input = '0' + input.substr(0, 5);
        }

        if(ch == 'q' || ch == 'Q' || ch == 27){
            run = false;
            return Timer(0,0,0);
        }

        h = stoi(input.substr(0, 2));
        m = stoi(input.substr(2, 2));
        s = stoi(input.substr(4, 2));

        to_print = (h < 10 ? "0" : "") + to_string(h) + ":" 
                 + (m < 10 ? "0" : "") + to_string(m) + ":" 
                 + (s < 10 ? "0" : "") + to_string(s);

        _display.tickTimerSetup(to_print);
        
        wait(LOOPTIME);

        if(_testing){
            break;
        }
    }
    _display.clearScreen();
    Timer timer(h,m,s);
    return timer;
}

Alarm Menu::createAlarm(bool& run){
    int h = 0;
    int m = 0;

    string input = "0000";

    string to_print = "00:00";

    bool isAM = true;

    _display.tickAlarmSetup(to_print, isAM);
    
    int index = 3;
    
    
    while (true) {
        char ch; 

        if(_testing){
            ch = '1';
        }

        else if(_kbhit()){
            ch = _getch();

            if(ch == -32 || ch == 224 || ch == 0){
                ch = getch();
                switch(ch){
                    case 75:
                        isAM = 1;
                        break;
                    case 77:
                        isAM = 0;
                        break;   
                    default:
                        break; 
                }
            }
        }

        else{
            ch = 0;
        }

        if (ch == 13 && h) {
            break;
        } 
        else if (ch >= '0' && ch <= '9') {
            input = input.substr(1) + ch; 
        } 
        else if (ch == 8) { 
            input = '0' + input.substr(0, 3);
        }

        if(ch == 'q' || ch == 'Q' || ch == 27){
            run = false;
            return Alarm(0,0);
        }

        h = stoi(input.substr(0, 2));
        m = stoi(input.substr(2, 2));

        if(h > 12) { 
            h = 12; 
        }

        if(h && m > 59) { 
            m = 59; 
        }

        to_print = (h < 10 ? "0" : "") + to_string(h) + ":" 
                 + (m < 10 ? "0" : "") + to_string(m);

        input = to_print.substr(0, 2) + to_print.substr(3, 2);

        _display.tickAlarmSetup(to_print, isAM);
        
        wait(LOOPTIME);

        if(_testing){
            break;
        }
    }
    _display.clearScreen();
    Alarm alarm(0,0);
    
    if(isAM){
        if(h == 12){
            alarm = Alarm(0,m);
        }
        else{
            alarm = Alarm(h,m);
        }
    }
    else{
        if(h == 12){
            alarm = Alarm(12,m);
        }
        else{
            alarm = Alarm(h+12,m);
        }
    }
    return alarm;
}

void Menu::wait(double seconds) {
    int milli = 1000 * seconds;
    this_thread::sleep_for(chrono::milliseconds(milli));
}

/* =========================================================
WAIT FOR ANY USER INPUT
========================================================= */

void Menu::waitForInput() {
    if(_testing){
        return;
    }
    _getch();
}

/* =========================================================
HANDLE KEYBOARD INPUT FOR TIMER
========================================================= */

void Menu::checkTimerInput(Timer& timer, bool& run){
    if(_kbhit() || _testing){
        char ch;
        if(!_testing) { ch = _getch(); }
        if(_testing) { ch = 's'; }
        if(ch == 's' || ch == 'S'){
            if(timer.isRunning()){
                timer.pause();
                _display.setSplash("TIMER PAUSED");
            }
            else if(timer.remainingMilliseconds() > 0){
                _display.clearSplash();
                timer.resume();        
            }
        }
        if(_testing) { ch = 'r'; }
        if(ch == 'R' || ch == 'r'){
            timer.reset();
            _display.clearScreen();
            _display.setSplash("TIMER RESET, PRESS 'S' TO START");
        }
        if(_testing) { ch = 'a'; }
        if(ch == 'A' || ch == 'a'){
            _display.clearScreen();
            _display.clearSplash();
            timer = createTimer(run);
        }
        if(_testing) { ch = 'q'; }
        if(ch == 'Q' || ch == 'q' || ch == 27){
            _display.clearSplash();
            run = false;
            return;
        }
    }
}

/* =========================================================
HANDLE KEYBOARD INPUT FOR STOPWATCH
========================================================= */

void Menu::checkStopwatchInput(Stopwatch& stopwatch, bool& run){
    if(_kbhit() || _testing){
        char ch;
        if(!_testing) { ch = _getch(); }
        if(_testing) { ch = 's'; }
        if(ch == 's' || ch == 'S'){
            if(stopwatch.isRunning()){
                stopwatch.pause();
                if ((stopwatch.currentMilliseconds() / 10) % 100 == 0){
                    int i = rand() % _stopMessages.size();
                    _display.setSplash(_stopMessages[i]);
                }
                else{
                    _display.setSplash("STOPWATCH PAUSED");
                }
            }
            else{
                _display.clearSplash();
                stopwatch.resume();        
            }
        }
        if(_testing) { ch = 'r'; }
        if(ch == 'R' || ch == 'r'){
            stopwatch.reset();
            _display.clearScreen();
            _display.setSplash("STOPWATCH RESET, PRESS 'S' TO START");
        }
        if(_testing) { ch = 'a'; }
        if(ch == 'A' || ch == 'a'){
            stopwatch.addSplit();
            _display.setSplash("SPLIT CREATED");
        }
        if(_testing) { ch = 'q'; }
        if(ch == 'Q' || ch == 'q' || ch == 27){
            _display.clearSplash();
            run = false;
            return;
        }
        return;
    }
}

/* =========================================================
HANDLE KEYBOARD INPUT FOR ALARM
========================================================= */

void Menu::checkAlarmInput(Alarm& alarm, bool& run){
    if(_kbhit() || _testing){
        char ch;
        if(!_testing) { ch = _getch(); }
        if(_testing) { ch = 'a'; }
        if(ch == 'A' || ch == 'a'){
            _display.clearScreen();
            _display.clearSplash();
            alarm = createAlarm(run);
        }
        if(_testing) { ch = 'q'; }
        if(ch == 'Q' || ch == 'q' || ch == 27){
            _display.clearSplash();
            run = false;
            return;
        }
        return;
    }
}
/* =========================================================
GET USER INPUT FOR MENU SELECTION
========================================================= */

char Menu::getMenuInput(int& selected){
    while(true){
        if(_kbhit() || _testing){
            char ch = -1;
            if(!_testing) { ch = _getch(); }

            if(ch == 13){
                return selected + '1';
            }

            if(ch == -32 || ch == 224 || ch == 0){
                ch = getch();
                switch(ch){
                    case 72:
                        selected = max(0,selected-1);
                        break;
                    case 80:
                        selected = min(4,selected+1);
                        break;   
                    default:
                        break; 
                }
                return '0';
            }
            
            else{
                if(_testing) { ch = 27; }
                switch(ch){
                    case '1':
                    case '2':
                    case '3':
                        selected = ch - '1';
                        return ch;
                    case 'S':
                    case 's':
                        selected = 3;
                        return 's';
                    case 'Q':
                    case 'q':
                    case 27:
                        selected = 4;
                        return 'q';
                    default:
                        break;         
                }
            }

        }
        wait(LOOPTIME); // Slight delay before checking input again
    }
}

char Menu::getSettingsInput(int& selected){
    while(true){
        if(_kbhit() || _testing){
            char ch = -1;
            if(!_testing) { ch = _getch(); }

            if(ch == 13){
                printArt(_settingsBlank, "");
                return selected + '1';
            }

            if(ch == -32 || ch == 224 || ch == 0){
                ch = getch();
                switch(ch){
                    case 72:
                        selected = max(0,selected-1);
                        break;
                    case 80:
                        selected = min(3,selected+1);
                        break;   
                    default:
                        break; 
                }
                return '0';
            }
            else{
                if(_testing) { ch = 27; }
                switch(ch){
                    case '1':
                    case '2':
                    case '3':
                        selected = ch - '1';
                        return ch;
                    case 'Q':
                    case 'q':
                    case 27:
                        selected = 3;
                        return 'q';
                    default:
                        break;         
                }
            }
        }
        wait(LOOPTIME); // Slight delay before checking input again
    }
}